{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "98b0a7c0ea82cde3",
   "metadata": {},
   "source": [
    "## 基于多树GP的特征工程（Feature Construction）\n",
    "在机器学习中，特征工程是非常重要的一环。特征工程的目的是从原始数据中提取出更有用的特征，以提高机器学习算法的性能。  \n",
    "特征工程的方法有很多，比如特征降维（PCA、ICA、LDA）、特征选择、特征构造等。其中，特征构造是指从原始数据中构造出新的特征，以提高机器学习算法的性能。  \n",
    "特征构造的方法有很多，比如多项式特征构造、基于树的特征构造、基于聚类的特征构造、基于神经网络的特征构造等。  \n",
    "本文将介绍如何使用遗传编程（GP）来进行特征构造。遗传编程是一种进化算法，基于树结构演化，它很适合用于构造机器学习算法所需的特征。  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f2bb043976a3e6d",
   "metadata": {},
   "source": [
    "### 评估函数\n",
    "特征工程是指遗传编程（GP）用于构造机器学习算法所需的特征，而后续的预测操作由机器学习算法来执行。因此，评估函数内部需要内置机器学习算法或特征质量评估函数。\n",
    "值得一提的是，如果使用机器学习算法进行评估，为了避免过拟合，最好使用交叉验证误差来评估特征工程的效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fc1a30604c8470c4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-09T04:59:20.636807400Z",
     "start_time": "2023-11-09T04:59:20.446034Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "\n",
    "# 假设我们有一个分类问题，输入为X，输出为y\n",
    "X,y=load_iris(return_X_y=True)\n",
    "\n",
    "# 求解问题的目标是最大化分类精度\n",
    "def evalFeatureEngineering(individuals):\n",
    "    # 创建新特征\n",
    "    new_features = []\n",
    "    for ind_num, ind in enumerate(individuals):\n",
    "        func = gp.compile(expr=ind, pset=pset)\n",
    "        new_features.append([func(*record) for record in X])\n",
    "    \n",
    "    # 转置新特征数组\n",
    "    new_features = np.transpose(np.array(new_features))\n",
    "    \n",
    "    # 使用决策树分类器\n",
    "    clf = DecisionTreeClassifier()\n",
    "    clf.fit(new_features, y)\n",
    "    \n",
    "    # 使用交叉验证计算误差\n",
    "    scores = cross_val_score(clf, new_features, y, cv=5)\n",
    "    \n",
    "    # 返回平均分类精度\n",
    "    return scores.mean(),"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a80f5c352efe1e1",
   "metadata": {},
   "source": [
    "### 多树GP 个体表示\n",
    "实现多树GP的方法有很多，最简单的方式是使用列表结构来表示一个个体，列表中的每个元素都是一棵树。\n",
    "当然，为了后续的可扩展性，更建议创建一个类来表示个体，类中包含一个列表，列表中的每个元素都是一棵树。不过，这里为了简单起见，我们直接使用列表结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "initial_id",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-09T04:59:20.679216700Z",
     "start_time": "2023-11-09T04:59:20.482165500Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zhenl\\anaconda3\\Lib\\site-packages\\deap\\gp.py:254: RuntimeWarning: Ephemeral rand101 function cannot be pickled because its generating function is a lambda function. Use functools.partial instead.\n",
      "  warnings.warn(\"Ephemeral {name} function cannot be \"\n",
      "C:\\Users\\zhenl\\anaconda3\\Lib\\site-packages\\deap\\creator.py:185: RuntimeWarning: A class named 'FitnessMax' has already been created and it will be overwritten. Consider deleting previous creation of that class or rename it.\n",
      "  warnings.warn(\"A class named '{0}' has already been created and it \"\n",
      "C:\\Users\\zhenl\\anaconda3\\Lib\\site-packages\\deap\\creator.py:185: RuntimeWarning: A class named 'Individual' has already been created and it will be overwritten. Consider deleting previous creation of that class or rename it.\n",
      "  warnings.warn(\"A class named '{0}' has already been created and it \"\n"
     ]
    }
   ],
   "source": [
    "import operator\n",
    "import random\n",
    "import numpy as np\n",
    "from deap import base, creator, tools, gp, algorithms\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "# 创建GP框架的基本组件\n",
    "pset = gp.PrimitiveSet(\"MAIN\", X.shape[1])\n",
    "pset.addPrimitive(operator.add, 2)\n",
    "pset.addPrimitive(operator.sub, 2)\n",
    "pset.addPrimitive(operator.mul, 2)\n",
    "pset.addPrimitive(operator.neg, 1)\n",
    "pset.addEphemeralConstant(\"rand101\", lambda: random.random() * 2 - 1)\n",
    "\n",
    "# 创建一个适应度类和个体类，个体由多棵树组成\n",
    "creator.create(\"FitnessMax\", base.Fitness, weights=(1.0,))\n",
    "creator.create(\"Individual\", list, fitness=creator.FitnessMax)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd8becab808db0eb",
   "metadata": {},
   "source": [
    "### 交叉/变异算子\n",
    "对于多树GP，很明显我们还需要自己定义交叉和变异算子。这里我们对DEAP中的交叉和变异算子进行简单包装，将其改造成能够处理多棵树的列表结构的算子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d8cb2ce19a609f6b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-09T04:59:20.679216700Z",
     "start_time": "2023-11-09T04:59:20.527861Z"
    }
   },
   "outputs": [],
   "source": [
    "toolbox = base.Toolbox()\n",
    "toolbox.register(\"expr\", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)\n",
    "\n",
    "# 初始化每个个体为一个包含多棵树的列表\n",
    "def initIndividual(container, func, size):\n",
    "    return container(gp.PrimitiveTree(func()) for _ in range(size))\n",
    "\n",
    "# 交叉和变异算子需要能够处理个体的列表结构\n",
    "def cxOnePointListOfTrees(ind1, ind2):\n",
    "    for tree1, tree2 in zip(ind1, ind2):\n",
    "        gp.cxOnePoint(tree1, tree2)\n",
    "    return ind1, ind2\n",
    "\n",
    "def mutUniformListOfTrees(individual, expr, pset):\n",
    "    for tree in individual:\n",
    "        gp.mutUniform(tree, expr=expr, pset=pset)\n",
    "    return individual,\n",
    "\n",
    "toolbox.register(\"individual\", initIndividual, creator.Individual, toolbox.expr, size=3)  # 假设我们创建3个特征\n",
    "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n",
    "\n",
    "toolbox.register(\"evaluate\", evalFeatureEngineering)\n",
    "toolbox.register(\"select\", tools.selTournament, tournsize=3)\n",
    "toolbox.register(\"mate\", cxOnePointListOfTrees)\n",
    "toolbox.register(\"mutate\", mutUniformListOfTrees, expr=toolbox.expr, pset=pset)\n",
    "toolbox.register(\"compile\", gp.compile, pset=pset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed604d829d2b72e3",
   "metadata": {},
   "source": [
    "最后，演化流程与传统的GP算法没有区别。直接运行即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2e84206ae4aefe45",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-09T04:59:24.698382500Z",
     "start_time": "2023-11-09T04:59:20.544545500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gen\tnevals\tavg     \tstd      \tmin     \tmax \n",
      "0  \t50    \t0.915733\t0.0385691\t0.826667\t0.98\n",
      "1  \t46    \t0.908667\t0.0837377\t0.506667\t0.973333\n",
      "2  \t50    \t0.935067\t0.0384548\t0.72    \t0.966667\n",
      "3  \t40    \t0.939467\t0.0211172\t0.866667\t0.966667\n",
      "4  \t46    \t0.947467\t0.0147054\t0.913333\t0.966667\n",
      "5  \t47    \t0.939467\t0.0541904\t0.586667\t0.98    \n",
      "6  \t46    \t0.947067\t0.017558 \t0.886667\t0.98    \n",
      "7  \t48    \t0.947067\t0.0238667\t0.866667\t0.98    \n",
      "8  \t44    \t0.9512  \t0.0178109\t0.9     \t0.98    \n",
      "9  \t48    \t0.944667\t0.069439 \t0.473333\t0.98    \n",
      "10 \t49    \t0.947867\t0.0237277\t0.846667\t0.98    \n",
      "Best individual is: ['sub(ARG1, ARG2)', 'mul(sub(ARG2, 0.7606802124690533), ARG3)', 'add(ARG0, -0.053137453689096725)']\n",
      "With fitness: (0.9800000000000001,)\n"
     ]
    }
   ],
   "source": [
    "# 运行遗传编程算法\n",
    "population = toolbox.population(n=50)\n",
    "hof = tools.HallOfFame(1)\n",
    "\n",
    "# 统计和日志\n",
    "stats = tools.Statistics(lambda ind: ind.fitness.values)\n",
    "stats.register(\"avg\", np.mean)\n",
    "stats.register(\"std\", np.std)\n",
    "stats.register(\"min\", np.min)\n",
    "stats.register(\"max\", np.max)\n",
    "\n",
    "pop, log = algorithms.eaSimple(population, toolbox, 0.9, 0.1, 10, stats=stats, halloffame=hof, verbose=True)\n",
    "\n",
    "# 查看最佳个体\n",
    "best_ind=hof[0]\n",
    "print('Best individual is:', [str(tree) for tree in best_ind])\n",
    "print('With fitness:', best_ind.fitness.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "当然，最后也可以利用NetworkX库来对所有GP树进行可视化。"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c9083393f2ef0fc1"
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1a7852839997aeb0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-09T04:59:25.159175300Z",
     "start_time": "2023-11-09T04:59:24.613687900Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8TElEQVR4nO3dd1zU9+E/8NcdQ2QIiApuTRpjvGNJNO49Ytq036Zp+mvatEmcKNEIiHvvgQKy4bgjjkSjsWpcOHEvVMYlRusgGndEQBEE7vP7w2hjohHw7t6fu3s9H48+HjWS+7wolfeLz+u8U0iSJIGIiIhsllJ0ACIiIhKLZYCIiMjGsQwQERHZOJYBIiIiG8cyQEREZONYBoiIiGwcywAREZGNs6/KBxkMBly5cgVubm5QKBSmzkRERERGIEkSiouL0ahRIyiVz/75v0pl4MqVK2jatKnRwhEREZH5XLp0CU2aNHnm71epDLi5uT1+sDp16hgnGREREZlUUVERmjZt+vgcf5YqlYFH00CdOnVYBoiIiCzM8yZ+PoGQiIjIxrEMEBER2TiWASIiIhvHMkBERGTjWAaIiIhsHMsAERGRjWMZICIisnEsA0RERDaOZYCIiMjGsQwQERHZOJYBIiIiG8cyQEREZONYBoiIiGxcld61kIisR3l5JXJybiIr6zpOnLiBq1fvoqysErVq2aFhQ1e0bdsAQUHe8POrDwcHO9FxicgMWAaIbER+fiGSknKQmJiNgoJSAICDgxLl5YbHH+PgoERS0sNfe3o6Ydgwfwwd6ofmzd2FZCYi81BIkiQ974OKiorg7u6OwsJC1KlTxxy5iMhICgvLEB6+BxpNLpRKBSorn/tH/jE7OwUMBgkDB/oiMrIH6tSpZcKkRGRsVT2/+ZwBIiuWkXERrVunQavNgyShWkUAePjxkgRotXlo3ToNGRkXTROUiIRiGSCyUrGxJ9C//xrcuFFS7RLwS5WVEq5fL0H//msQF3fSSAmJSC5YBoisUFzcSXzyyS4AgMHwYkXgkUePExKyk4WAyMqwDBBZmYyMiwgJ2WnSa4SE7ORkQGRFWAaIrEhhYRn+/e8tUCoVJr2OUqnAhx9uQVFRmUmvQ0TmwTJAZEXCw/fg5s0So00Dz2IwSLhxowRhYXtMeh0iMg+WASIrcfFiITSa3Bd+smBVVVZK0GhykZ9faJbrEZHpsAwQWYnk5Bx06NAQX331J+TnD0Fp6ae4di0YBw++j0WLelT78f79bxUkKRxBQd7P/BilUoHk5JwXSE1EcsAyQGQFyssrce7cHezb93fUqeOIiIhM9Ou3BqNG7cKBAz/gb3971STXrayUkJCQjfLySpM8PhGZB1+OmMgK5OTcxPDhAbhwoRD9+695YipYteo7RERkmuzaBQWlyM29hbZtn30HgYjkjXcGiKxAVtZ1eHnVxq1b95/6nIGfv+i4JIVj6tROv/qYCxcGQ6t981f/3NPTCWlpb+LHH0fg7t1R2LDhz2jZ8sn3KsjKuv7inwQRCcMyQGQFTpy4gSNHrqJDh0aIju6F9u19YG9vnD/eGk1/GAwS3n9/Ez79dBfat/fBnj1/g7v7w/cpcHBQsgwQWTjOBERW4OrVu4iIyESrVp4YObItRo5siwcPKnHs2DVs3HgOsbEnce9eeY0e+/jxaxg0aNvjX+v1P+LgwfcxYkQA5sw5gvJyA65du2esT4WIBOCdASIrUFZWidu3S9Gt2xd4/fVlGDt2L9av/y9atfLEvHndkJv7Iby8atfosVes+PaJXx86dAUXLxaiZ89mj/9ZaWnFC+UnIrF4Z4DICtSqZff4v2dlXX98297eXon587shNPR1RES0w9ixe6v92E/7qf/atXvw8nJ6/GsnJ34rIbJkvDNAZAUaNnSFg8Ov/zhXVBgwffpBAIBaXQ/Aw5/if14eHnnWnQMfH5en/rMffywF8PA5A0/7GCKyHCwDRFagbdsGzzzMX3vNCwBw5cpdAA9fqdDPr/4TH9OzZ1O4uTk+9d//xz9ee+LXHTs2QosW7tiz5xIAoLzc8JsvTERE8sd7e0RWICjIG9u2vYvLl4uxceM5nD59G0qlAgEBDRAW9jqKix8gOvoEAGDZsm8wc2YXTJ/eGZmZl9CmjRdCQgJx507pUx/79dd9kJLSD19+eQZNm7ph9uwuuHy5GPHxp564PhFZLpYBIivg51cfQ4duR+/ezTB6dBAaNnRFrVp2uHr1HnbsyMfcuUdw+vRtAMDChcdQp04tfPihCuHhr+Po0Wt4772NWL/+/5762AMHbsMHH7TBF1/8AbVq2WH37ksYNWoXCgoelgdPTyf4+tYz16dKRCagkCTpue9qUlRUBHd3dxQWFqJOnTrmyEVE1TRhwj4sWHDUbG9UBAB2dgqMHdses2d3Nds1iajqqnp+8zkDRFZi6FA/k7918S8ZDBKGDPEz6zWJyPhYBoisRPPm7hg40Bd2dgqzXM/OToGBA33RvLn78z+YiGSNZYDIikRG9kCDBs5QKk1bCJRKBRo0cEZkZA+TXoeIzINlgMiK1KlTCzrdAJPPBQaDBJ1uAOrUqWXS6xCRebAMEFmZfv1aIDa2t0mvERfXG/36tTDpNYjIfFgGiKzQiBGBPysEBqM85qPpIS6uN4YPDzTKYxKRPLAMEFmpESMC8Yc/XANwD8oX/pNugJNTObZte5dFgMgKsQwQWaldu3bh668jsWBBPXz8sS8UClT7bxrY2SmgUAAdO9qjpGQa7O3PmygtEYnEFx0iskLFxcXw9fVFy5YtsXPnTiiVSuTnFyI5OQcJCdmPXz3QwUGJ8vL/zQg//7WnpxOCg/0xZIgfmjZ1Q69evZCfn4+cnBy4ubkJ+byIqHqqen6zDBBZoWHDhmH58uXIycnBSy+99MTvlZdXIjf31uO3Or527R5KSyvg5GQPHx8XBAV5IyjIG76+9eDg8L93Nzx//jz8/PzwwQcfICEhwdyfEhHVAMsAkY3KyMhA//79ER8fj+DgYKM+dnx8PEaMGIGMjAz07dvXqI9NRMbHMkBkgwoLC+Hr64tWrVohIyMDyhd/5uATDAYD+vbti7NnzyIvL4/fD4hkju9NQGSDwsPDUVBQAI1GY/QiAABKpRIajQYFBQUIDw83+uMTkRgsA0RWYuvWrUhNTUVkZCSaN29usuu0aNECixYtQkpKCrZt22ay6xCR+XAmILICd+7cgVqtRps2bbBt2zYoFKZ9bwJJktCvXz98++23yMvLg4eHh0mvR0Q1w5mAyIaMHj0axcXF0Gg0Ji8CAKBQKKDRaFBUVITQ0FCTX4+ITItlgMjCbdq0CTqdDkuWLEHTpk3Ndt1mzZphyZIl0Gq12LRpk9muS0TGx5mAyIIVFBRApVIhICAAmzZtMstdgZ+TJAlvvfUWcnJykJeXB09PT7Nen4h+G2cCIhswatQolJSUIDk52exFAHg4F6SkpODevXv49NNPzX59IjIOlgEiC7V+/XosW7YM0dHRaNKkibAcTZo0QVRUFD777DNs2LBBWA4iqjnOBEQW6Mcff4RKpUK7du2wYcMGIXcFfk6SJLz99tvIysqCXq9H3bp1heYhooc4ExBZsZEjR6KsrAxJSUnCiwDwcC5ITk5GaWkpRo4cKToOEVUTywCRhfnqq6+wcuVKLF26FI0aNRId57FGjRohJiYGK1aswLp160THIaJq4ExAZEFu3rwJlUqFTp06Yd26dbK4K/BzkiTh//7v/3D48GHo9XrUq1dPdCQim8aZgMgKhYSEoLKyEomJibIrAsDDuSApKQkVFRUICQkRHYeIqohlgMhCfPnll1i9ejXi4uLg4+MjOs4z+fj4IDY2FqtWrcKaNWtExyGiKuBMQGQBbty4AZVKhW7dumHNmjWyvCvwc5Ik4S9/+Qv27dsHvV6PBg0aiI5EZJM4ExBZCUmSMHz4cABAQkKC7IsA8HAuSEhIeJy9Cj9zEJFALANEMrdq1SqsXbsW8fHxFvUTtre3N+Lj47F27VqsXr1adBwi+g2cCYhk7Nq1a1CpVOjTpw9WrVolOk6NvPfee9i1axf0ej28vb1FxyGyKZwJiCycJEkYNmwY7OzsEBsbKzpOjcXFxUGpVCI4OJhzAZFMsQwQydTKlSuxfv16JCQkoH79+qLj1Fj9+vWRkJCAdevW4fPPPxcdh4iegjMBkQxduXIFarUab775JlauXCk6jlH8/e9/x7Zt26DX69GwYUPRcYhsAmcCIgslSRKGDh0KR0dHLF26VHQco4mNjYWjoyOGDh3KuYBIZlgGiGRm2bJl+Prrr5GUlAQvLy/RcYzGy8sLSUlJ2LhxI5YvXy46DhH9DGcCIhn54YcfoFKp8Pbbb2PZsmWi45jEP//5T2zatAl5eXlo3Lix6DhEVo0zAZGFkSQJgwcPhrOzM6Kjo0XHMZmYmBg4OTlhyJAhnAuIZIJlgEgmtFottmzZguTkZNStW1d0HJOpW7cukpOTsXnzZuh0OtFxiAicCYhk4dKlS1Cr1XjnnXeg1WpFxzGLDz/8EOvWrUNeXh6aNm0qOg6RVeJMQGQhJEnCoEGD4ObmhiVLloiOYzZRUVFwdXXF4MGDORcQCcYyQCRYamoqMjIykJKSAg8PD9FxzMbDwwMpKSnYtm0bNBqN6DhENo1lgEig/Px8hIaGYuDAgRgwYIDoOGb31ltv4eOPP0ZoaCjy8/NFxyGyWXzOAJEgkiShb9++OHPmDHJzc+Hu7i46khCFhYVQq9Vo3bo1MjIyLOItmoksBZ8zQCRzSUlJ2LlzJzQajc0WAQBwd3eHRqPBjh07kJycLDoOkU1iGSAS4MKFCwgPD8eQIUPQt29f0XGE69evHwYPHoywsDBcuHBBdBwim8OZgMjMDAYDevfujQsXLiA3Nxdubm6iI8lCUVERfH198fLLL2PHjh1QKvmzCtGL4kxAJFPx8fHYs2cPNBoNi8DP1KlTBxqNBrt370ZCQoLoOEQ2hWWAyIzOnTuHsWPHYvjw4ejdu7foOLLTp08fBAcHIyIiAufOnRMdh8hmcCYgMhODwYAePXrg8uXLyMnJgaurq+hIsnT37l34+vqiWbNm2L17N+cCohfAmYBIZpYuXYp9+/YhLS2NReA3uLq6Ii0tDXv37kVsbKzoOEQ2gWWAyAzOnDmD8ePH45NPPkGPHj1Ex5G9nj17IiQkBOPGjcPZs2dFxyGyepwJiEyssrIS3bp1w/Xr15GdnQ0XFxfRkSzCvXv34Ofnh4YNGyIzMxN2dnaiIxFZHM4ERDIRHR2NQ4cOQavVsghUg4uLC3Q6HQ4ePIiYmBjRcYisGssAkQmdPn0aEydOxKhRo9C1a1fRcSxO165dMXLkSEyYMAHfffed6DhEVoszAZGJVFZWonPnzrh9+zZOnToFZ2dn0ZEsUklJCfz9/VGvXj3s37+fcwFRNXAmIBIsMjISR48ehU6nYxF4Ac7OztDpdDhy5AgWL14sOg6RVWIZIDKBb775BpMnT0ZYWBg6deokOo7F69y5M0JDQzF58mR8++23ouMQWR3OBERGVlFRgU6dOqGoqAgnT55E7dq1RUeyCvfv30dgYCDc3d1x4MAB2Nvbi45EJHucCYgEWbhwIbKysqDT6VgEjKh27drQ6XQ4fvw4Fi1aJDoOkVVhGSAyotzcXEydOhVjxoxBhw4dRMexOh06dEB4eDimTp2KvLw80XGIrAZnAiIjKS8vR4cOHVBaWoqsrCw4OTmJjmSVSktL0bZtWzg7O+PQoUNwcHAQHYlItjgTEJnZ/PnzkZ2dDZ1OxyJgQk5OTkhPT8epU6ewYMEC0XGIrALLAJERZGdnY8aMGRg7dizatWsnOo7Va9euHSIiIjB9+nTk5OSIjkNk8TgTEL2gBw8e4I033kBFRQWOHz+OWrVqiY5kE8rKyhAUFAQHBwccPXqUcwHRU3AmIDKTOXPmIDc3F+np6SwCZlSrVi2kp6cjNzcXc+bMER2HyKKxDBC9gJMnT2L27NmYOHEi2rZtKzqOzQkKCsKECRMwa9YsnDp1SnQcIovFmYCohh48eIDXX38dSqUSR48ehaOjo+hINunBgwePn6dx7Ngxfh2IfoYzAZGJzZw5E99++y10Oh0PIIEcHR2h0+nwzTffYNasWaLjEFkklgGiGjh+/Djmzp2LyZMnIyAgQHQcmxcYGIhJkyZhzpw5yMrKEh2HyOJwJiCqpkfPYnd0dMSRI0f4LHaZKC8vR/v27VFeXo6srCw+mZMInAmITGb69Ok4c+YM0tPTWQRkxMHBAenp6Thz5gxmzJghOg6RRWEZIKqGo0ePYv78+Zg6dSp8fX1Fx6Ff8PPzw5QpUzBv3jwcO3ZMdBwii8GZgKiKSktLERgYCBcXFxw+fJhvoStT5eXl6NixI0pKSnDixAm+NDTZNM4EREY2ZcoUnD9/Hunp6SwCMubg4ACdTodz585h6tSpouMQWQSWAaIqOHToECIjIzFjxgyoVCrRceg51Go1pk+fjkWLFuHw4cOi4xDJHmcCoue4f/8+AgIC4OHhgQMHDvCugIWoqKhA586dUVhYiJMnT6J27dqiIxGZHWcCIiOZNGkS8vPzodPpWAQsiL29PbRaLS5evIjJkyeLjkMkaywDRL9h//79WLJkCWbNmoXXXntNdByqpjZt2mDmzJlYvHgxDhw4IDoOkWxxJiB6hpKSEvj7+6N+/frYt28f7OzsREeiGqisrESXLl1w69YtZGdnw9nZWXQkIrPhTED0giZMmIDLly9Dp9OxCFgwOzs76HQ6XL58GRMnThQdh0iWWAaIniIzMxPR0dGYM2cOWrVqJToOvaBXX30Vs2fPRnR0NPbu3Ss6DpHscCYg+oW7d+/C398fjRo1wp49e3hXwEpUVlaie/fuuHr1KnJycuDi4iI6EpHJcSYgqqFx48bh6tWr0Gq1LAJWxM7ODlqtFlevXsW4ceNExyGSFZYBop/ZvXs34uLiMH/+fPzud78THYeM7JVXXsG8efMQGxuLPXv2iI5DJBucCYh+UlxcDD8/PzRv3hy7du2CUsmubI0MBgN69uyJ77//Hrm5uXB1dRUdichkOBMQVVNERARu3ryJtLQ0FgErplQqkZaWhhs3biAiIkJ0HCJZ4Hc8IgDbt29HYmIiFixYgJdeekl0HDKxl19+GQsWLEBCQgJ27NghOg6RcJwJyOYVFRVBrVbjlVdewfbt23lXwEYYDAb06dMH586dQ25uLr+3kVXiTEBUReHh4SgoKIBGo2ERsCGP5oLbt29jzJgxouMQCcXvfGTTtm3bhpSUFCxatAgtWrQQHYfMrEWLFli4cCGSk5ORkZEhOg6RMJwJyGbduXMHarUar732GjIyMqBQKERHIgEkSUK/fv1w+vRp5OXlwd3dXXQkIqPhTED0HKGhoSgqKoJGo2ERsGEKhQKpqakoLCxEaGio6DhEQrAMkE3avHkztFotlixZgmbNmomOQ4I1b94cixcvRlpaGrZs2SI6DpHZcSYgm1NQUAC1Wg0/Pz9s3ryZdwUIwMO5YMCAAcjNzUVeXh48PT1FRyJ6YZwJiJ7h008/xb1795CSksIiQI8pFAqkpKTg7t27GD16tOg4RGbFMkA2ZePGjfjss88QFRWFJk2aiI5DMtO0aVNERUUhPT0dGzduFB2HyGw4E5DNuH37NlQqFYKCgrBx40beFaCnkiQJf/jDH3Dy5Enk5eWhbt26oiMR1RhnAqJfGDlyJEpLS5GcnMwiQM+kUCiQnJyM+/fvY9SoUaLjEJkFywDZhHXr1mHFihWIiYlBo0aNRMchmWvcuDGio6OxfPly/Oc//xEdh8jkOBOQ1bt16xZUKhU6dOiA//znP7wrQFUiSRL+9Kc/4ciRI9Dr9ahXr57oSETVxpmA6CchISGoqKhAUlISiwBVmUKhQFJSEsrLy/HJJ5+IjkNkUiwDZNXWrFmDVatWITY2Fj4+PqLjkIVp2LAhYmNj8cUXX2Dt2rWi4xCZDGcCslo3btyASqVC165dsXbtWt4VoBqRJAnvvPMODhw4AL1ej/r164uORFRlnAnIpkmShOHDh0OSJCQkJLAIUI0pFAokJibCYDBgxIgRouMQmQTLAFml1atXY+3atYiPj4e3t7foOGThvL29ERcXhy+//BKrV68WHYfI6DgTkNW5fv06VCoVevXqxW/cZDSSJOG9997D7t27odfrWTLJInAmIJskSRKCg4OhVCoRFxcnOg5ZEYVCgfj4eCiVSgQHB6MKP0cRWQyWAbIqn3/+OdatW4eEhAQ+0YuMrn79+oiPj8e6devwxRdfiI5DZDScCchqXL16FSqVCv3798fnn38uOg5Zsf/3//4fMjIyoNfr0bBhQ9FxiJ6JMwHZFEmSMHToUDg6OiI2NlZ0HLJysbGxcHBwwLBhwzgXkFVgGSCrsHz5cmzcuBFJSUnw8vISHYesXL169ZCYmIgNGzZgxYoVouMQvTDOBGTxfvjhB6jVavz+97/H8uXLRcchG/KPf/wDmzdvhl6v5xtgkSxxJiCbIEkShgwZAicnJ8TExIiOQzYmJiYGTk5OGDJkCOcCsmgsA2TRdDodNm/ejOTkZNStW1d0HLIxXl5eSEpKwqZNm5Ceni46DlGNcSYgi3X58mWoVCr8+c9/hk6nEx2HbNi///1vrF+/Hnl5eWjSpInoOESPcSYgqyZJEgYNGgRXV1dERUWJjkM2LioqCi4uLhg8eDDnArJILANkkTQaDbZt24bU1FR4eHiIjkM2ztPTEykpKdi6dSvS0tJExyGqNpYBsjj5+fkIDQ3Fxx9/jAEDBoiOQwQAeOutt/DRRx9h9OjR+P7770XHIaoWlgGyKI/mAXd3dyxevFh0HKInLF68GO7u7hg0aBDnArIoLANkUZKTk7Fjxw5oNBq4u7uLjkP0BA8PD6SmpmL79u1ISUkRHYeoylgGyGJcuHABYWFhGDx4MPr16yc6DtFT9e/fH4MGDUJYWBguXrwoOg5RlfCvFpJFMBgM6NOnD86dO4fc3Fz+/5BkraioCGq1Gq+88gq2b98OpZI/d5EY/KuFZFUSEhKwe/duaDQaFgGSvTp16iAtLQ27du1CYmKi6DhEz8UyQLJ3/vx5REREIDg4GH369BEdh6hK+vTpg2HDhiEiIgLnz58XHYfoN3EmIFkzGAzo2bMnvv/+e+Tm5sLV1VV0JKIqKy4uhp+fH5o3b45du3ZxLiCz40xAViE2NhZ79+6FVqtlESCL4+bmhrS0NGRmZiIuLk50HKJnYhkg2Tp79izGjRuHkJAQ9OjRQ3Qcohrp2bMnRowYgbFjx+K///2v6DhET8WZgGSpsrIS3bt3x9WrV5GTkwMXFxfRkYhq7O7du/D390ejRo2QmZnJuYDMhjMBWbSYmBgcPHgQOp2ORYAsnqurK7RaLfbv34+YmBjRcYh+hWWAZOe7777DhAkTMHLkSHTt2lV0HCKj6NatG0aOHInx48fjzJkzouMQPYEzAclKZWUlunTpglu3biE7OxvOzs6iIxEZzb179xAQEID69etj3759sLOzEx2JrBxnArJIixcvxpEjR6DT6VgEyOq4uLhAq9Xi8OHDWLJkieg4RI+xDJBsfPvtt5g8eTJCQ0PRuXNn0XGITKJLly4YPXo0Jk2ahNOnT4uOQwSAMwHJREVFBTp37ozCwkKcPHkStWvXFh2JyGTu37+PgIAAeHh44MCBA7C3txcdiawUZwKyKIsWLcLx48eh0+lYBMjq1a5dGzqdDsePH0dkZKToOEQsAyReXl4epk6divDwcHTo0EF0HCKz6NixI8LCwjBlyhTo9XrRccjGcSYgocrLy9GxY0eUlJTgxIkTcHJyEh2JyGxKS0sRGBgIV1dXHDp0iHMBGR1nArIICxYswKlTp5Cens4iQDbHyckJ6enpOHHiBBYsWCA6DtkwlgESJicnB9OnT0dERATatWsnOg6REO3bt0dERASmTZuG3Nxc0XHIRnEmICHKy8vRvn17lJeXIysrC7Vq1RIdiUiYsrIyBAUFwdHREUeOHIGDg4PoSGQlOBOQrM2ZMwe5ublIT09nESCbV6tWLeh0OuTk5GDu3Lmi45ANYhkgszt16hRmzZqFCRMmICgoSHQcIll4/fXXMX78eMycOROnTp0SHYdsDGcCMqsHDx48fn7AsWPH4OjoKDgRkXw8+vOhUChw9OhR/vmgF8aZgGRp1qxZ+Oabb5Cens5vdES/4OjoCJ1OB71ej9mzZ4uOQzaEZYDMJisrC3PmzMGkSZMQEBAgOg6RLAUGBmLixImYPXs2Tpw4IToO2QjOBGQWZWVleP3112Fvb4+jR4/y2dJEv+HBgwd44403UFlZiWPHjvFJtlRjnAlIVmbMmIHvvvsO6enpLAJEz/FoLjh9+jRmzpwpOg7ZAJYBMrljx45h3rx5mDJlCvz8/ETHIbII/v7+mDx5MubNm4djx46JjkNWjjMBmVRpaSnatm0LZ2dnHDp0iHcFiKqhvLwcHTp0QGlpKbKysviS3VRtnAlIFqZOnYpz585Bp9OxCBBVk4ODA9LT03H27FlMmzZNdByyYiwDZDKHDx/GokWLMH36dKjVatFxiCySWq3G9OnTsXDhQhw5ckR0HLJSnAnIJO7fv4/AwEC4u7vjwIEDfGtWohdQUVGBTp06obi4GCdOnEDt2rVFRyILwZmAhJo8eTIuXrwInU7HIkD0guzt7aHT6XD+/HlMmTJFdByyQiwDZHQHDhzA4sWLMXPmTLz22mui4xBZhTZt2mDmzJmIjIzEwYMHRcchK8OZgIyqpKQEAQEB8PLywv79+2FnZyc6EpHVqKysRJcuXfDjjz/i1KlTcHZ2Fh2JZI4zAQkxceJEXLp0CTqdjkWAyMjs7Oyg0+lw6dIlTJo0SXQcsiIsA2Q0e/fuRXR0NGbPno1XX31VdBwiq/Tqq69i1qxZiIqKwr59+0THISvBmYCM4t69e/Dz80PDhg2RmZnJuwJEJlRZWYlu3brh+vXryM7OhouLi+hIJFOcCcisxo8fj6tXr0Kr1bIIEJmYnZ0dtFotrly5ggkTJoiOQ1aAZYBe2J49e7B06VLMmzcPr7zyiug4RDahVatWmDt3LmJiYpCZmSk6Dlk4zgT0Qu7evQtfX180a9YMu3fvhlLJfklkLgaDAT169MDly5eRk5MDV1dX0ZFIZjgTkFlERETgxo0b0Gq1LAJEZqZUKqHVanH9+nWMHTtWdByyYPzuTTW2c+dOJCQkYMGCBXjppZdExyGySS+//DLmz5+P+Ph47Nq1S3QcslCcCahGioqK4Ovri5dffhk7duzgXQEigQwGA3r37o0LFy4gNzcXbm5uoiORTHAmIJMaM2YMbt++jbS0NBYBIsGUSiXS0tJw69YtjBkzRnQcskD8Lk7VlpGRgeTkZCxcuBAtWrQQHYeIALRs2RILFy5EUlISMjIyRMchC8OZgKqlsLAQarUarVu3RkZGBhQKhehIRPQTg8GAfv364cyZM8jNzYW7u7voSCQYZwIyibCwMBQWFiI1NZVFgEhmlEolNBoNCgoKEB4eLjoOWRCWAaqyLVu2QKPRYPHixWjevLnoOET0FM2bN8fixYuRmpqKrVu3io5DFoIzAVVJQUEB1Go1fH19sWXLFt4VIJIxSZLw5ptvQq/XIy8vDx4eHqIjkSCcCcioRo8ejbt373IeILIACoUCqampKC4uxujRo0XHIQvAMkDPtXHjRqSnpyMqKgpNmjQRHYeIqqBp06ZYsmQJdDodNm3aJDoOyRxnAvpNt2/fhlqtRmBgIL7++mveFSCyIJIk4fe//z1OnToFvV4PT09P0ZHIzDgTkFGMGjUK9+/fR3JyMosAkYVRKBRISUlBSUkJRo0aJToOyRjLAD3Tf/7zHyxfvhzR0dFo3Lix6DhEVAONGzdGdHQ0li1bhvXr14uOQzLFmYCe6scff4RKpUL79u2xfv163hUgsmCSJOGPf/wjjh07Br1eDy8vL9GRyEw4E9AL+eSTT/DgwQMkJSWxCBBZOIVCgaSkJDx48AAjR44UHYdkiGWAfmXt2rX4/PPPERsbi4YNG4qOQ0RG0KhRIyxduhQrV67EV199JToOyQxnAnrCzZs3oVKp0KVLF6xdu5Z3BYisiCRJeOedd3DgwAHo9XrUr19fdCQyMc4EVCMjRoyAwWBAQkICiwCRlVEoFEhISEBlZSVCQkJExyEZYRmgx1avXo0vv/wScXFx8Pb2Fh2HiEzAx8cHcXFxj/+8EwGcCegn169fh0qlQs+ePbF69WreFSCyYpIk4a9//SsyMzOh1+vRoEED0ZHIRDgTUJVJkoTg4GAolUrEx8ezCBBZOYVCgfj4eADA8OHDUYWfCcnKsQwQvvjiC6xbtw7x8fF8QhGRjWjQoAHi4+Oxdu1arFq1SnQcEowzgY27du0aVCoV+vbtiy+++EJ0HCIys7/97W/YsWMH9Ho9fHx8RMchI+NMQM8lSRKGDRsGe3t7xMbGio5DRALExcXB3t4ew4YN41xgw1gGbNiKFSuwfv16JCYmol69eqLjEJEA9erVQ2JiItavX4+VK1eKjkOCcCawUVeuXIFKpcLvf/97LF++XHQcIhLsH//4B7Zs2YK8vDw0atRIdBwyEs4E9EySJGHIkCFwcnJCTEyM6DhEJAMxMTFwdHTE0KFDORfYIJYBG5Seno5NmzYhKSkJdevWFR2HiGTAy8sLSUlJ+Prrr/HZZ5+JjkNmxpnAxly+fBlqtRp/+tOfkJ6eLjoOEcnMv/71L2zYsAF6vR6NGzcWHYdeEGcC+hVJkjB48GC4uLggKipKdBwikqHo6Gg4Oztj8ODBnAtsCMuADUlLS8PWrVuRkpICT09P0XGISIY8PT2RkpKCLVu2QKvVio5DZsKZwEZ8//33UKvVePfdd5GWliY6DhHJ3EcffYSvvvoKeXl5aNq0qeg4VEOcCegxSZIwaNAguLu7Y/HixaLjEJEFWLJkCdzc3DBo0CDOBTaAZcAGpKSkYPv27UhNTYWHh4foOERkATw8PJCamoqMjAykpqaKjkMmxjJg5S5evIiwsDAMHjwY/fv3Fx2HiCzIm2++iUGDBiE0NBT5+fmi45AJ8TkDVsxgMKBv377473//i9zcXH7tiKjaioqKoFar0apVK2zfvp1vcW5h+JwBQlJSEnbt2gWNRsMiQEQ1UqdOHWg0GuzcuRNJSUmi45CJsAxYqfPnz2PMmDEYNmwY+vTpIzoOEVmwvn37YujQoQgPD8eFCxdExyET4ExghQwGA3r16oX8/Hzk5OTAzc1NdCQisnDFxcXw9fVFy5YtsXPnTiiV/FnSEnAmsGFxcXHIzMxEWloaiwARGYWbmxvS0tKwZ88exMfHi45DRsYyYGX++9//YuzYsRgxYgR69uwpOg4RWZFevXph+PDhGDt2LM6dOyc6DhkRZwIrYjAY0L17d1y5cgXZ2dlwdXUVHYmIrMzdu3fh5+eHJk2aYM+ePZwLZI4zgQ2KiYnB/v37odVqWQSIyCRcXV2h1Wqxb98+LF26VHQcMhKWAStx5swZjB8/HqNGjUK3bt1ExyEiK9a9e3eMHDkS48ePx5kzZ0THISPgTGAFKisr0bVrV9y8eRPZ2dlwdnYWHYmIrNy9e/fg7+8Pb29v7N27F3Z2dqIj0VNwJrAhUVFROHz4MLRaLYsAEZmFi4sLtFotDh06hOjoaNFx6AWxDFi406dPY+LEiRg9ejS6dOkiOg4R2ZCuXbvi008/xcSJE3H69GnRcegFcCawYBUVFejcuTPu3LmDU6dOoXbt2qIjEZGNKSkpQWBgIDw9PXHgwAHOBTLDmcAGREZG4vjx49DpdCwCRCSEs7MztFotjh49isjISNFxqIZYBiyUXq/HlClTEBYWho4dO4qOQ0Q2rFOnTggLC8PkyZPxzTffiI5DNcCZwAJVVFSgY8eOuHv3Lk6ePAknJyfRkYjIxt2/fx9t27aFm5sbDh48CHt7e9GRCJwJrNqCBQtw4sQJpKenswgQkSzUrl0bOp0OWVlZWLhwoeg4VE0sAxYmNzcX06ZNw9ixY9G+fXvRcYiIHnvjjTcQERGBqVOnIjc3V3QcqgbOBBakvLwcb7zxBh48eICsrCzUqlVLdCQioieUlZWhbdu2cHJywuHDh+Hg4CA6kk3jTGCF5s2bh5ycHOh0OhYBIpKlWrVqQafTITs7G/Pnzxcdh6qIZcBCnDp1CjNmzMD48ePx+uuvi45DRPRM7dq1w7hx4zBjxgxkZ2eLjkNVwJnAAjx48ADt27eHJEk4duwYHB0dRUciIvpNZWVlaNeuHezs7HDkyBF+3xKEM4EVmT17NvR6PXQ6Hf9AEZFFeDQX5ObmYs6cOaLj0HOwDMjciRMnMHv2bEycOBGBgYGi4xARVVnbtm0xceJEzJ49GydPnhQdh34DZwIZ4202IrJ0j2ZOg8GA48eP8/uYmXEmsAIzZ87E6dOnOQ8QkcVydHREeno6vv32W8ycOVN0HHoGlgGZOnbsGObNm4cpU6bA399fdBwiohrz9/fHlClTMHfuXBw/flx0HHoKzgQyVFpaiqCgIL5oBxFZjfLycnTo0AFlZWV80TQz4kxgwaZPn46zZ88iPT2dRYCIrIKDgwN0Oh3OnDmD6dOni45Dv8AyIDNHjhzBggULMH36dKjVatFxiIiMxtfXF9OmTcP8+fNx9OhR0XHoZzgTyAjfApSIrB3fgt28OBNYoClTpuD8+fPQ6XQsAkRklezt7ZGeno7z589jypQpouPQT1gGZOLgwYOIjIzEzJkz0aZNG9FxiIhMpk2bNpgxYwYiIyNx6NAh0XEInAlkoaSkBAEBAfDy8sL+/fthZ2cnOhIRkUlVVFSgS5cuKCgowKlTp1C7dm3RkawSZwILMmnSJFy6dAk6nY5FgIhsgr29PXQ6HfLz8zFp0iTRcWwey4Bg+/btQ1RUFGbNmoVXX31VdBwiIrNp3bo1Zs2ahSVLlmD//v2i49g0zgQC3bt3D/7+/vD29sbevXt5V4CIbE5lZSW6du2KmzdvIjs7G87OzqIjWRXOBBZgwoQJuHLlCrRaLYsAEdkkOzs76HQ6XL58GRMmTBAdx2axDAiSmZmJmJgYzJ07F61atRIdh4hImFatWmHu3LmIjo5GZmam6Dg2iTOBAHfv3oWfnx+aNGmCPXv2QKlkJyMi22YwGNCjRw/88MMPyM7Ohqurq+hIVoEzgYyNHTsW169fh1arZREgIgKgVCqRlpaGq1evYty4caLj2ByeRGa2a9cuxMfHY/78+Xj55ZdFxyEiko3f/e53mD9/PuLi4rB7927RcWwKZwIzKi4uhq+vL1q2bImdO3fyrgAR0S8YDAb06tUL+fn5yMnJgZubm+hIFo0zgQyNGTMGt27dQlpaGosAEdFTPJoLbt68iYiICNFxbAZPJDPJyMhAUlISFi5ciJYtW4qOQ0QkWy+99BIWLFiAxMREbN++XXQcm8CZwAwKCwvh6+uLVq1aISMjg3cFiIiew2AwoG/fvjh79izy8vJ49tQQZwIZCQ8PR0FBATQaDYsAEVEVKJVKaDQaFBQUIDw8XHQcq8eTycS2bt2K1NRULF68GM2bNxcdh4jIYrRo0QKRkZFISUnBtm3bRMexapwJTOjOnTtQq9VQqVTYunUrFAqF6EhERBZFkiT0798f33zzDfLy8uDh4SE6kkXhTCADo0ePRnFxMVJTU1kEiIhqQKFQIDU1FUVFRQgNDRUdx2qxDJjIpk2boNPpsGTJEjRt2lR0HCIii9WsWTMsWbIEWq0WmzdvFh3HKnEmMIGCggKoVCoEBARg06ZNvCtARPSCJEnCW2+9hZycHOTl5cHT01N0JIvAmUCgUaNGoaSkBCkpKSwCRERGoFAokJKSgnv37uHTTz8VHcfqsAwY2fr167Fs2TJER0ejcePGouMQEVmNJk2aICoqCp999hk2bNggOo5V4UxgRD/++CNUKhXatWuHDRs28K4AEZGRSZKEt99+G1lZWdDr9ahbt67oSLLGmUCAkSNH4sGDB0hKSmIRICIyAYVCgeTkZJSWlmLkyJGi41gNlgEj+eqrr7By5UosXboUjRo1Eh2HiMhqNWrUCEuXLsWKFSuwbt060XGsAmcCI7h58yZUKhU6d+6Mr776incFiIhMTJIk/PnPf8ahQ4eg1+tRr1490ZFkiTOBGYWEhKCyshIJCQksAkREZqBQKJCYmIiKigqEhISIjmPxWAZe0JdffonVq1cjLi4OPj4+ouMQEdkMHx8fxMbGYtWqVVizZo3oOBaNM8ELuHHjBlQqFbp3744vv/ySdwWIiMxMkiS8++672Lt3L/R6PRo0aCA6kqxwJjAxSZIwfPhwAEB8fDyLABGRAAqFAgkJCQCA4cOHowo/39JTsAzU0KpVq7B27VrEx8eziRIRCdSgQQPExcVh7dq1WL16teg4FokzQQ1cu3YNKpUKffr0wapVq0THISIiAO+99x527doFvV4Pb29v0XFkgTOBiUiShGHDhsHe3h5xcXGi4xAR0U/i4uKgVCoRHBzMuaCaWAaqaeXKlVi/fj0SExP591qJiGSkfv36SEhIwLp16/D555+LjmNROBNUw5UrV6BWqzFgwACsWLFCdBwiInqK999/H1u3boVer0fDhg1FxxGKM4GRSZKEoUOHwtHRETExMaLjEBHRMyxduhSOjo4YOnQo54IqYhmoomXLluHrr79GUlISvLy8RMchIqJn8PLyQlJSEjZu3Ijly5eLjmMROBNUwQ8//ACVSoU//vGP+Oyzz0THISKiKvjggw/w9ddfIy8vD40bNxYdRwjOBEYiSRIGDx4MZ2dnREdHi45DRERVFB0djdq1a2PIkCGcC56DZeA5tFottmzZgpSUFHh6eoqOQ0REVVS3bl0kJydj8+bN0Ol0ouPIGmeC33Dp0iWo1Wq888470Gq1ouMQEVENfPjhh1i3bh30ej2aNGkiOo5ZcSZ4QZIkYdCgQXBzc8OSJUtExyEiohqKioqCq6srBg0axLngGVgGniE1NRUZGRlITU2Fh4eH6DhERFRDHh4eSE1NxbZt26DRaETHkSWWgafIz89HaGgoBg0ahDfffFN0HCIiekEDBgzAwIEDERoaivz8fNFxZIfPGfgFSZLQt29fnDlzBnl5eVb/+RIR2YrCwkKo1Wq0bt0aGRkZNvHW83zOQA0lJSVh586d0Gg0LAJERFbE3d0dGo0GO3bsQHJysug4ssIy8DMXLlxAeHg4hg4dir59+4qOQ0RERtavXz8MGTIEYWFhuHDhgug4ssGZ4CcGgwG9e/fGhQsXkJubCzc3N9GRiIjIBIqLi+Hr64uXXnoJO3bsgFJpvT8Xcyaopvj4eOzZswdpaWksAkREVszNzQ0ajQa7d+9GQkKC6DiywDIA4Ny5cxg7diyGDx+OXr16iY5DREQm1rt3bwQHByMiIgLnz58XHUc4m58JDAYDevTogcuXLyMnJweurq6iIxERkRncvXsXvr6+aNasGXbv3m2VcwFngipaunQp9u3bB61WyyJARGRDXF1dodVqsXfvXsTGxoqOI5RNl4EzZ85g/PjxGDlyJLp37y46DhERmVmPHj3wySefYNy4cTh79qzoOMLY7ExQWVmJbt264fr168jOzoaLi4voSEREJMC9e/fg7+8PHx8fZGZmws7OTnQko6nq+W1vxkwmUVlejps5ObielYUbJ07g7tWrqCwrg12tWnBt2BAN2raFd1AQ6vv5wc7B4fG/Fx0djUOHDiEzM5NFgIjIhrm4uECr1aJ79+6IiYnB6NGjn/j9mp4zlsRi7wwU5ucjJykJ2YmJKC0oAAAoHRxgKC9//DE//7WTpyf8hw2D39ChuHr/PgIDAxEcHIzFixcLyU9ERPIyevRoJCYm4tSpU3j11Vdf6Jxxb95cyOfwS1U9vy2uDJQVFmJPeDhyNRoolEpIlZVV/ncVdnaQDAacr1cPe+vUwdGcHDg7O5swLRERWYqSkhIEBATA290dE/39kZeWVuNzxnfgQPSIjEQtwWemVf5tgosZGUhr3Rp5Wi0gSdX6AgF4+PGShBY3b2LwnTu4sX+/iZISEZGlcXZ2xpLgYPQ8fhy5aWkvdM7kabVIa90aFzMyTJTWuCymDJyIjcWa/v1RcuNGtb84v6QEUFFQgDX9++NkXJxxAhIRkUU7ERuLb0ND4aZQQPH8m+a/SaqsRMn16xZzzlhEGTgZF4ddn3wCAJAMBqM85qPH2RkSYhFfKCIiMp2fnzMvWgQesaRzRvZl4GJGBnaGhJj0GjtDQizmVg4RERkXzxmZl4GywkJs+fe/oTDxS0QqlEps+fBDlBUVmfQ6REQkLzxnHpJ1GdgTHo6SmzeNNg08i2QwoOTGDewJCzPpdYiISF54zjwk2zJQePEicjWaXz1ZsL9Gg09LS1FPrf7Vv9N+7FiESxJe+sMfAABtPvgAf/j8c3x8+jTCKisx+MKFZ15PqqxErkaDwvx8434iREQkS087Z6p6xrj4+KDzzJl4/+BBDL95E58UFuKfx4/Db/DgZ95lkPM5I9sykJOc/NT/QXd/+ilKrl3DgPR0KO3/9wKK9dRqdJo+HXlaLc5//TWAh2XAS6XC1aNHcefcuedeU6FUIic52XifBBERydbTzpmqnjHeQUFQ/etfyN+5E1v+9S9s+MtfcDkzE30SEtAvJeWZ15TrOSPLFx2qLC9Hgrf341d8+qVmvXvjrxkZODRzJg5OmwalvT3+eewYnOrWhc7XFw8ebTIKBfDTp/fnjRtRT61GSsuWv3ltJ09PBF+/brEvKUlERM/3W+dMVc6YWh4eKL97F4aKiif+3d5LlyIwJARJTZui+PLlp17bnOeMRb/o0M2cnGcWAQD4fudOZCcm4o0JE+Ddti06TZuGBgEB2DZw4P+KAPC4CFRHaUEBbuXm1iQ2ERFZiN86Z6pyxpTdufOrIgAAV48eBQC4NmnyzGvL8ZyRZRm4npX13I/JHDMGxd9/jz+uWYP2Y8fiVEIC8nfsMNv1iYjIcj3v+3xNz5hmvXqhsrwcBWfOvND1zU2WZeDGiRNQPuf2SXlJCfZPmgT3li1RcvMmMseMMcq1lQ4OsvsiERGRcT3vnKnJGdO8b1+0+eADnFy6FKW3bz/z4+R4zsiyDNy9evWJd4V6KoUCgZ98AkNlJZwbNEB9f3+jXNtQXo57164Z5bGIiEiennvOVPOMaRAYiLdXr8bVw4exb/z43/xYOZ4zsiwDlWVlz/2YduHhaNypEza9/z4Kzp7Fm2lpsHdyMsr1K0pLjfI4REQkT887Z6pzxjQICMBft2/HnbNnsfatt1D54MFzry+3c0aWZcCuVq3f/H2v115D5xkzoE9Px3erV2Prhx/C43e/Q5fZs41yfWOVCiIikqffOmeqc8Y0CAjAX3fsQFF+Pr7s1+/JJ7H/BrmdM7IsA64NGz5zy1HY2WFAejru37qFXaNGAQCuHjmCrMWL0XbUKDTq1OmFrq10cICLj88LPQYREcnbs86Z6pwx9f398dcdO1B8+TK+7NsXZXfuVOnacjxnZFkGGrRt+8wt543x4+HTrh22DRqEssLCx/98/+TJv7qV4/Xaa2j1l7+g1V/+AhcfHzg4Oz/+tddrrz318Q3l5fAOCjL+J0VERLLxrHOmqmeMZ6tW+OtPf7tg/8SJ8HzlFTR8443H/6ldr94zry3Hc8b++R9ifs/6H6m+nx86Tp6M7ORkXNy27Ynfqywrw9YPP8TfDxxAl9mzsScsDK++9x46TZv2xMf9cc0aAMDBadNwcPr0al2fiIisw9O+z1fnjLmZkwPnnw78d3561duf2/Lhh9Cnp1fr+iJZ5CsQmhJfgZCIyPrZyjlj0a9AaOfgAP9hw6CwszPrdRV2dvAPDmYRICKycjxnniTLMgAAfkOHmvwtJX9JMhjgN2SIWa9JRERi8Jz5H9mWAffmzeE7cKDZWpvCzg6+AwfCvXlzs1yPiIjE4jnzP7ItAwDQIzISzg0aPPO9oY1FoVTCuUED9IiMNOl1iIhIXnjOPCTrMlCrTh0M0OlMfhtHMhgwQKdDLTM8OZKIiOSD58xDsi4DANCiXz/0jo016TV6x8WhRb9+Jr0GERHJE88ZCygDABA4YsTjL5SxbuU8epzecXEIHD7cKI9JRESWydbPGYsoA8DDL9S727bB2dv7hZ/sobCzg7O3N97dtk32XyAiIjIPWz5nLKYMAA9v5Xz87bdQf/QRoFBU+4ulsLMDFAqoP/oIH58+LetbNkREZH62es7I8hUIq6IwPx85ycnITkh4/ApSSgeHJ15r+ue/dvL0hH9wMPyGDJHlX+sgIiJ5sYZzpqrnt8WWgUcqy8txKzcX17OycD0rC/euXUNFaSnsnZzg4uMD76AgeAcFoZ6vr+xe8YmIiOTPks8ZmykDRERE9HQW/d4EREREZD4sA0RERDaOZYCIiMjGsQwQERHZOJYBIiIiG8cyQEREZONYBoiIiGwcywAREZGNYxkgIiKycSwDRERENo5lgIiIyMaxDBAREdk4lgEiIiIbZ1+VD3r0xoZFRUUmDUNERETG8+jcft4bFFepDBQXFwMAmjZt+oKxiIiIyNyKi4vh7u7+zN9XSM+rCwAMBgOuXLkCNzc3KBQKowYkIiIi05AkCcXFxWjUqBGUymc/M6BKZYCIiIisF59ASEREZONYBoiIiGwcywAREZGNYxkgIiKycSwDRERENo5lgIiIyMaxDBAREdm4/w9V+mak82MD4gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/O0lEQVR4nO3dd1RUZ/4G8GeGIlIERMXekqjJUESiMfZeUnezSXaz2f3FxIq9YG+xxhKqdBhmMGqiscSuWLE3lDbRaCzEiqiEKgoz9/eHkdWoEZGZd8rzOSfnrDPD3GcOy7zP3O+de2WSJEkgIiIiiyUXHYCIiIjEYhkgIiKycCwDREREFo5lgIiIyMKxDBAREVk4lgEiIiILxzJARERk4azL8yCdTodr167ByckJMplM35mIiIioEkiShPz8fNStWxdy+bM//5erDFy7dg0NGjSotHBERERkOJcvX0b9+vWfeX+5yoCTk1PZk1WrVq1ykhEREZFe5eXloUGDBmXr+LOUqww8HA1Uq1aNZYCIiMjEPG/EzwMIiYiILBzLABERkYVjGSAiIrJwLANEREQWjmWAiIjIwrEMEBERWTiWASIiIgvHMkBERGThWAaIiIgsHMsAERGRhWMZICIisnAsA0RERBaOZYCIiMjCleuqhURkPkpKtEhLy0ZychZOnryJ69cLcO+eFlWqWKFOHUe0alULvr7u8PKqCRsbK9FxicgAWAaILERmZi6io9MQFZWKnJxiAICNjRwlJbqyx9jYyBEd/eDfrq52GDLEG4MHe6FRI2chmYnIMGSSJEnPe1BeXh6cnZ2Rm5uLatWqGSIXEVWS3Nx78PffC6UyHXK5DFrtc//ky1hZyaDTSejf3xMBAV1QrVoVPSYlospW3vWbxwwQmbHExEto0SIeKlUGJAkvVASAB4+XJEClykCLFvFITLykn6BEJBTLAJGZCgs7id69V+PmzaIXLgF/ptVKyMoqQu/eqxEefqqSEhKRsWAZIDJD4eGnMGLEbgCATvdyReChh88zfPguFgIiM8MyQGRmEhMvYfjwXXrdxvDhuzgyIDIjLANEZiQ39x6++GIr5HKZXrcjl8vQr99W5OXd0+t2iMgwWAaIzIi//15kZxdV2mjgWXQ6CTdvFmHcuL163Q4RGQbLAJGZuHQpF0pl+ksfLFheWq0EpTIdmZm5BtkeEekPywCRmYiJSSsbD4wY4QNJ8kd6er9y//wXXyggSf5o1Oj55xK5eHEgVKo+kMtliIlJq2hkIjISLANEZqCkRIuoqNSyvQJffeUJAPDwqIE2bWrrbbtarYTIyFSUlGj1tg0i0j+WASIzkJaWXXaKYV9fd7RsWQubNp0HAPTv76nXbefkFCM9/ZZet0FE+sUyQGQGkpOzyv73w8V/0qT9OHjwKv71rxaoWvXxy5C89VYdHDjwGe7eHY2rV4dg/vyOsLF58u3A2lqOhQs74fp1PxQWjsL+/f9C69ZP7ml4dPtEZHpYBojMwMmTN2FjI4ednTU++6wFjh27Do3mFuLj01GtWhV88knzsse+/robdu36FC4uVdCv31YMGbIDPj61MG3a2088b2xsL/j7t8bSpRp8+OFPWLPmHNau/RCurnZlj7GxkbMMEJk4XrWQyAxcv16AkhId/vnPFnBxsYNSmQ4AWLnyFwQHd0P//h5YulQDAJgx423IZEC3bqtw82YRAGDz5gvIyOj32HM2b14d/fp5IDDwBCZO3AcA2LkzE1lZhVix4r2yx5WU6HDjRqEBXiUR6Qv3DBCZgXv3HhzA17+/J4qKSvDDD2cAAIWFJfjxx1/QqVMDvPqqCwCga9cG2LXrt7IiADw4b8DKlb889pxduzYAACxffvqx21et+uWJAwaLi0sr9fUQkWGxDBCZgSpVrPDKKy7o1Kk+Nm++AJlMBmfnKnB2roLVq88C+N83DNzcqj71k/yfb3Nzq/rU27VaCbdvFz92m50ddzISmTL+BROZgTp1HNGuXV3I5TJ88knzx44ReOiLLxSYNu0Abt++i9q1HZ64/8+33b59t+z2a9cKym63spLBze3xYwae9nxEZDpYBojMgK9vLbzzTlP8+msOBgxIfOL+995rCn//1ujbtwn27LmMDz54BbVq2ZeNCuRyGf75z8cLxN69lwEAn3/+Ok6e/N8Bgp9+2hw2NlZl/y4p0cHX110fL4uIDIRlgMgMdO3aEPXqOWHChCQkJV1+4v6MjFsYPtwH/ft7Yvr0g/jgg1ewe/enmD37MIqKSjBsmA8cHGwe+5kzZ+7gu+80GD3aFyUlOuzcmQkPjxrw938TubmPX6CIZYDItPGYASIz0LSpC+7d00Klynjq/bdv38W6defw3ntNkZ1dhB49fkRe3n0kJPRFTEwvpKVlY86cw0/8XP/+2xEYeAL9+imwYcPf8OmnzfGPf2woO8ERALi62sHTs4beXhsR6Z9MkqTnXtUkLy8Pzs7OyM3NRbVqzz9vOREZ3pQp+7Fo0TGDXagIeHD8wMSJbTBvXkeDbZOIyq+86zf3DBCZicGDvfR+6eI/0+kkDBrkZdBtElHlYxkgMhONGjmjf39PWFnJDLI9KysZ+vf3RKNGzgbZHhHpD8sAkRkJCOiCWrXsyy5lrC9yuQy1atkjIKCLXrdDRIbBMkBkRqpVqwK1uq/exwU6nQS1ui+qVaui1+0QkWGwDBCZmV69GiMsrLtetxEe3h29ejXW6zaIyHBYBojM0LBhPo8UAl2lPOfD0UN4eHcMHepTKc9JRMaBZYDITA0b5oP33rsBoBDyl/5L18HOrgTbt3/MIkBkhlgGiMzU7t27sWlTABYtqoGvvvKETIYX/qaBlZUMMhnw9tvWKCr6GtbWF/SUlohE4kmHiMxQfn4+PD090aRJE+zatQtyuRyZmbmIiUlDZGRq2RkEbWzkKCn53xjh0X+7utrBz88bgwZ5oUEDJ3Tr1g2ZmZlIS0uDk5OTkNdFRC+mvOs3ywCRGRoyZAiWLVuGtLQ0NG3a9LH7Skq0SE+/heTkLCQnZ+HGjUIUF5fCzs4atWs7wNfXHb6+7vD0rPHYBYkuXLgALy8v/Pe//0VkZKShXxIRVQDLAJGFSkxMRO/evREREQE/P79Kfe6IiAgMGzYMiYmJ6NmzZ6U+NxFVPpYBIguUm5sLT09PNGvWDImJiZC//JGDj9HpdOjZsyfOnTuHjIwMvh8QGTlem4DIAvn7+yMnJwdKpbLSiwAAyOVyKJVK5OTkwN/fv9Kfn4jEYBkgMhPbtm1DXFwcAgIC0KhRI71tp3Hjxvj2228RGxuL7du36207RGQ4HBMQmYHff/8dHh4eeOONN7B9+3bIZPq9NoEkSejVqxdOnz6NjIwMuLi46HV7RFQxHBMQWZAxY8YgPz8fSqVS70UAAGQyGZRKJfLy8jB27Fi9b4+I9ItlgMjEbd68GWq1GkFBQWjQoIHBttuwYUMEBQVBpVJh8+bNBtsuEVU+jgmITFhOTg4UCgVatmyJzZs3G2SvwKMkScI777yDtLQ0ZGRkwNXV1aDbJ6K/xjEBkQUYNWoUioqKEBMTY/AiADwYF8TGxqKwsBCjR482+PaJqHKwDBCZqPXr1+O7775DSEgI6tevLyxH/fr1ERwcjKVLl2LDhg3CchBRxXFMQGSCbt++DYVCgdatW2PDhg1C9go8SpIkvP/++0hOToZGo0H16tWF5iGiBzgmIDJjI0eOxL179xAdHS28CAAPxgUxMTEoLi7GyJEjRcchohfEMkBkYtauXYsVK1ZgyZIlqFu3rug4ZerWrYvQ0FAsX74c69atEx2HiF4AxwREJiQ7OxsKhQLt2rXDunXrjGKvwKMkScLf/vY3HDlyBBqNBjVq1BAdiciicUxAZIaGDx8OrVaLqKgooysCwINxQXR0NEpLSzF8+HDRcYionFgGiEzEjz/+iFWrViE8PBy1a9cWHeeZateujbCwMKxcuRKrV68WHYeIyoFjAiITcPPmTSgUCnTq1AmrV682yr0Cj5IkCf/4xz+wf/9+aDQa1KpVS3QkIovEMQGRmZAkCUOHDgUAREZGGn0RAB6MCyIjI8uyl+MzBxEJxDJAZORWrlyJNWvWICIiwqQ+Ybu7uyMiIgJr1qzBqlWrRMchor/AMQGREbtx4wYUCgV69OiBlStXio5TIZ9++il2794NjUYDd3d30XGILArHBEQmTpIkDBkyBFZWVggLCxMdp8LCw8Mhl8vh5+fHcQGRkWIZIDJSK1aswPr16xEZGYmaNWuKjlNhNWvWRGRkJNatW4fvv/9edBwiegqOCYiM0LVr1+Dh4YE+ffpgxYoVouNUis8++wzbt2+HRqNBnTp1RMchsggcExCZKEmSMHjwYNja2mLJkiWi41SasLAw2NraYvDgwRwXEBkZlgEiI/Pdd99h06ZNiI6Ohpubm+g4lcbNzQ3R0dHYuHEjli1bJjoOET2CYwIiI3L16lUoFAq8//77+O6770TH0Yv//Oc/2Lx5MzIyMlCvXj3RcYjMGscERCZGkiQMHDgQ9vb2CAkJER1Hb0JDQ2FnZ4dBgwZxXEBkJFgGiIyESqXC1q1bERMTg+rVq4uOozfVq1dHTEwMtmzZArVaLToOEYFjAiKjcPnyZXh4eOCjjz6CSqUSHccg+vXrh3Xr1iEjIwMNGjQQHYfILHFMQGQiJEnCgAED4OTkhKCgINFxDCY4OBiOjo4YOHAgxwVEgrEMEAkWFxeHxMRExMbGwsXFRXQcg3FxcUFsbCy2b98OpVIpOg6RRWMZIBIoMzMTY8eORf/+/dG3b1/RcQzunXfewVdffYWxY8ciMzNTdBwii8VjBogEkSQJPXv2xNmzZ5Geng5nZ2fRkYTIzc2Fh4cHWrRogcTERJO4RDORqeAxA0RGLjo6Grt27YJSqbTYIgAAzs7OUCqV2LlzJ2JiYkTHIbJILANEAly8eBH+/v4YNGgQevbsKTqOcL169cLAgQMxbtw4XLx4UXQcIovDMQGRgel0OnTv3h0XL15Eeno6nJycREcyCnl5efD09MQrr7yCnTt3Qi7nZxWil8UxAZGRioiIwN69e6FUKlkEHlGtWjUolUrs2bMHkZGRouMQWRSWASIDOn/+PCZOnIihQ4eie/fuouMYnR49esDPzw8TJkzA+fPnRcchshgcExAZiE6nQ5cuXXDlyhWkpaXB0dFRdCSjVFBQAE9PTzRs2BB79uzhuIDoJXBMQGRklixZgv379yM+Pp5F4C84OjoiPj4e+/btQ1hYmOg4RBaBZYDIAM6ePYvJkydjxIgR6NKli+g4Rq9r164YPnw4Jk2ahHPnzomOQ2T2OCYg0jOtVotOnTohKysLqampcHBwEB3JJBQWFsLLywt16tRBUlISrKysREciMjkcExAZiZCQEBw+fBgqlYpF4AU4ODhArVbj0KFDCA0NFR2HyKyxDBDp0ZkzZzB16lSMGjUKHTt2FB3H5HTs2BEjR47ElClT8Msvv4iOQ2S2OCYg0hOtVov27dvjzp07SElJgb29vehIJqmoqAje3t6oUaMGDhw4wHEB0QvgmIBIsICAABw7dgxqtZpF4CXY29tDrVbj6NGjCAwMFB2HyCyxDBDpwc8//4zp06dj3LhxaNeuneg4Jq99+/YYO3Yspk+fjtOnT4uOQ2R2OCYgqmSlpaVo164d8vLycOrUKVStWlV0JLNw9+5d+Pj4wNnZGQcPHoS1tbXoSERGj2MCIkEWL16M5ORkqNVqFoFKVLVqVajVapw4cQLffvut6DhEZoVlgKgSpaenY+bMmRg/fjzatm0rOo7Zadu2Lfz9/TFz5kxkZGSIjkNkNjgmIKokJSUlaNu2LYqLi5GcnAw7OzvRkcxScXExWrVqBXt7exw+fBg2NjaiIxEZLY4JiAxs4cKFSE1NhVqtZhHQIzs7OyQkJCAlJQWLFi0SHYfILLAMEFWC1NRUzJ49GxMnTkTr1q1FxzF7rVu3xoQJEzBr1iykpaWJjkNk8jgmIHpJ9+/fx1tvvYXS0lKcOHECVapUER3JIty7dw++vr6wsbHBsWPHOC4gegqOCYgMZP78+UhPT0dCQgKLgAFVqVIFCQkJSE9Px/z580XHITJpLANEL+HUqVOYN28epk6dilatWomOY3F8fX0xZcoUzJ07FykpKaLjEJksjgmIKuj+/ft48803IZfLcezYMdja2oqOZJHu379fdpzG8ePH+XsgegTHBER6NmfOHJw+fRpqtZoLkEC2trZQq9X4+eefMXfuXNFxiEwSywBRBZw4cQLffPMNpk+fjpYtW4qOY/F8fHwwbdo0zJ8/H8nJyaLjEJkcjgmIXtDDo9htbW1x9OhRHsVuJEpKStCmTRuUlJQgOTmZB3MSgWMCIr2ZNWsWzp49i4SEBBYBI2JjY4OEhAScPXsWs2fPFh2HyKSwDBC9gGPHjmHhwoWYOXMmPD09RcehP/Hy8sKMGTOwYMECHD9+XHQcIpPBMQFRORUXF8PHxwcODg44cuQIL6FrpEpKSvD222+jqKgIJ0+e5KmhyaJxTEBUyWbMmIELFy4gISGBRcCI2djYQK1W4/z585g5c6boOEQmgWWAqBwOHz6MgIAAzJ49GwqFQnQceg4PDw/MmjUL3377LY4cOSI6DpHR45iA6Dnu3r2Lli1bwsXFBQcPHuReARNRWlqK9u3bIzc3F6dOnULVqlVFRyIyOI4JiCrJtGnTkJmZCbVazSJgQqytraFSqXDp0iVMnz5ddBwio8YyQPQXDhw4gKCgIMydOxevv/666Dj0gt544w3MmTMHgYGBOHjwoOg4REaLYwKiZygqKoK3tzdq1qyJ/fv3w8rKSnQkqgCtVosOHTrg1q1bSE1Nhb29vehIRAbDMQHRS5oyZQquXLkCtVrNImDCrKysoFarceXKFUydOlV0HCKjxDJA9BRJSUkICQnB/Pnz0axZM9Fx6CU1b94c8+bNQ0hICPbt2yc6DpHR4ZiA6E8KCgrg7e2NunXrYu/evdwrYCa0Wi06d+6M69evIy0tDQ4ODqIjEekdxwREFTRp0iRcv34dKpWKRcCMWFlZQaVS4fr165g0aZLoOERGhWWA6BF79uxBeHg4Fi5ciFdffVV0HKpkr732GhYsWICwsDDs3btXdBwio8ExAdEf8vPz4eXlhUaNGmH37t2Qy9mVzZFOp0PXrl3x22+/IT09HY6OjqIjEekNxwREL2jChAnIzs5GfHw8i4AZk8vliI+Px82bNzFhwgTRcYiMAt/xiADs2LEDUVFRWLRoEZo2bSo6DunZK6+8gkWLFiEyMhI7d+4UHYdIOI4JyOLl5eXBw8MDr732Gnbs2MG9AhZCp9OhR48eOH/+PNLT0/neRmaJYwKicvL390dOTg6USiWLgAV5OC64c+cOxo8fLzoOkVB85yOLtn37dsTGxuLbb79F48aNRcchA2vcuDEWL16MmJgYJCYmio5DJAzHBGSxfv/9d3h4eOD1119HYmIiZDKZ6EgkgCRJ6NWrF86cOYOMjAw4OzuLjkRUaTgmIHqOsWPHIi8vD0qlkkXAgslkMsTFxSE3Nxdjx44VHYdICJYBskhbtmyBSqVCUFAQGjZsKDoOCdaoUSMEBgYiPj4eW7duFR2HyOA4JiCLk5OTAw8PD3h5eWHLli3cK0AAHowL+vbti/T0dGRkZMDV1VV0JKKXxjEB0TOMHj0ahYWFiI2NZRGgMjKZDLGxsSgoKMCYMWNExyEyKJYBsigbN27E0qVLERwcjPr164uOQ0amQYMGCA4ORkJCAjZu3Cg6DpHBcExAFuPOnTtQKBTw9fXFxo0buVeAnkqSJLz33ns4deoUMjIyUL16ddGRiCqMYwKiPxk5ciSKi4sRExPDIkDPJJPJEBMTg7t372LUqFGi4xAZBMsAWYR169Zh+fLlCA0NRd26dUXHISNXr149hISEYNmyZfjpp59ExyHSO44JyOzdunULCoUCbdu2xU8//cS9AlQukiThww8/xNGjR6HRaFCjRg3RkYheGMcERH8YPnw4SktLER0dzSJA5SaTyRAdHY2SkhKMGDFCdBwivWIZILO2evVqrFy5EmFhYahdu7boOGRi6tSpg7CwMPzwww9Ys2aN6DhEesMxAZmtmzdvQqFQoGPHjlizZg33ClCFSJKEjz76CAcPHoRGo0HNmjVFRyIqN44JyKJJkoShQ4dCkiRERkayCFCFyWQyREVFQafTYdiwYaLjEOkFywCZpVWrVmHNmjWIiIiAu7u76Dhk4tzd3REeHo4ff/wRq1atEh2HqNJxTEBmJysrCwqFAt26deMbN1UaSZLw6aefYs+ePdBoNCyZZBI4JiCLJEkS/Pz8IJfLER4eLjoOmRGZTIaIiAjI5XL4+fmhHJ+jiEwGywCZle+//x7r1q1DZGQkD/SiSlezZk1ERERg3bp1+OGHH0THIao0HBOQ2bh+/ToUCgV69+6N77//XnQcMmP/+te/kJiYCI1Ggzp16oiOQ/RMHBOQRZEkCYMHD4atrS3CwsJExyEzFxYWBhsbGwwZMoTjAjILLANkFpYtW4aNGzciOjoabm5uouOQmatRowaioqKwYcMGLF++XHQcopfGMQGZvKtXr8LDwwPvvvsuli1bJjoOWZDPP/8cW7ZsgUaj4QWwyChxTEAWQZIkDBo0CHZ2dggNDRUdhyxMaGgo7OzsMGjQII4LyKSxDJBJU6vV2LJlC2JiYlC9enXRccjCuLm5ITo6Gps3b0ZCQoLoOEQVxjEBmawrV65AoVDg73//O9Rqteg4ZMG++OILrF+/HhkZGahfv77oOERlOCYgsyZJEgYMGABHR0cEBweLjkMWLjg4GA4ODhg4cCDHBWSSWAbIJCmVSmzfvh1xcXFwcXERHYcsnKurK2JjY7Ft2zbEx8eLjkP0wlgGyORkZmZi7Nix+Oqrr9C3b1/RcYgAAO+88w6+/PJLjBkzBr/99pvoOEQvhGWATMrD8YCzszMCAwNFxyF6TGBgIJydnTFgwACOC8iksAyQSYmJicHOnTuhVCrh7OwsOg7RY1xcXBAXF4cdO3YgNjZWdByicmMZIJNx8eJFjBs3DgMHDkSvXr1ExyF6qt69e2PAgAEYN24cLl26JDoOUbnwq4VkEnQ6HXr06IHz588jPT2d/z8ko5aXlwcPDw+89tpr2LFjB+Ryfu4iMfjVQjIrkZGR2LNnD5RKJYsAGb1q1aohPj4eu3fvRlRUlOg4RM/FMkBG78KFC5gwYQL8/PzQo0cP0XGIyqVHjx4YMmQIJkyYgAsXLoiOQ/SXOCYgo6bT6dC1a1f89ttvSE9Ph6Ojo+hIROWWn58PLy8vNGrUCLt37+a4gAyOYwIyC2FhYdi3bx9UKhWLAJkcJycnxMfHIykpCeHh4aLjED0TywAZrXPnzmHSpEkYPnw4unTpIjoOUYV07doVw4YNw8SJE/Hrr7+KjkP0VBwTkFHSarXo3Lkzrl+/jrS0NDg4OIiORFRhBQUF8Pb2Rt26dZGUlMRxARkMxwRk0kJDQ3Ho0CGo1WoWATJ5jo6OUKlUOHDgAEJDQ0XHIXoCywAZnV9++QVTpkzByJEj0bFjR9FxiCpFp06dMHLkSEyePBlnz54VHYfoMRwTkFHRarXo0KEDbt26hdTUVNjb24uORFRpCgsL0bJlS9SsWRP79++HlZWV6Ehk5jgmIJMUGBiIo0ePQq1WswiQ2XFwcIBKpcKRI0cQFBQkOg5RGZYBMhqnT5/G9OnTMXbsWLRv3150HCK96NChA8aMGYNp06bhzJkzouMQAeCYgIxEaWkp2rdvj9zcXJw6dQpVq1YVHYlIb+7evYuWLVvCxcUFBw8ehLW1tehIZKY4JiCT8u233+LEiRNQq9UsAmT2qlatCrVajRMnTiAgIEB0HCKWARIvIyMDM2fOhL+/P9q2bSs6DpFBvP322xg3bhxmzJgBjUYjOg5ZOI4JSKiSkhK8/fbbKCoqwsmTJ2FnZyc6EpHBFBcXw8fHB46Ojjh8+DDHBVTpOCYgk7Bo0SKkpKQgISGBRYAsjp2dHRISEnDy5EksWrRIdByyYCwDJExaWhpmzZqFCRMmoHXr1qLjEAnRpk0bTJgwAV9//TXS09NFxyELxTEBCVFSUoI2bdqgpKQEycnJqFKliuhIRMLcu3cPvr6+sLW1xdGjR2FjYyM6EpkJjgnIqM2fPx/p6elISEhgESCLV6VKFajVaqSlpeGbb74RHYcsEMsAGVxKSgrmzp2LKVOmwNfXV3QcIqPw5ptvYvLkyZgzZw5SUlJExyELwzEBGdT9+/fLjg84fvw4bG1tBSciMh4P/z5kMhmOHTvGvw96aRwTkFGaO3cufv75ZyQkJPCNjuhPbG1toVarodFoMG/ePNFxyIKwDJDBJCcnY/78+Zg2bRpatmwpOg6RUfLx8cHUqVMxb948nDx5UnQcshAcE5BB3Lt3D2+++Sasra1x7NgxHi1N9Bfu37+Pt956C1qtFsePH+dBtlRhHBOQUZk9ezZ++eUXJCQksAgQPcfDccGZM2cwZ84c0XHIArAMkN4dP34cCxYswIwZM+Dl5SU6DpFJ8Pb2xvTp07FgwQIcP35cdBwycxwTkF4VFxejVatWsLe3x+HDh7lXgOgFlJSUoG3btiguLkZycjJP2U0vjGMCMgozZ87E+fPnoVarWQSIXpCNjQ0SEhJw7tw5fP3116LjkBljGSC9OXLkCL799lvMmjULHh4eouMQmSQPDw/MmjULixcvxtGjR0XHITPFMQHpxd27d+Hj4wNnZ2ccPHiQl2YlegmlpaVo164d8vPzcfLkSVStWlV0JDIRHBOQUNOnT8elS5egVqtZBIhekrW1NdRqNS5cuIAZM2aIjkNmiGWAKt3BgwcRGBiIOXPm4PXXXxcdh8gsvPHGG5gzZw4CAgJw6NAh0XHIzHBMQJWqqKgILVu2hJubGw4cOAArKyvRkYjMhlarRYcOHXD79m2kpKTA3t5edCQychwTkBBTp07F5cuXoVarWQSIKpmVlRXUajUuX76MadOmiY5DZoRlgCrNvn37EBISgnnz5qF58+ai4xCZpebNm2Pu3LkIDg7G/v37RcchM8ExAVWKwsJCeHl5oU6dOkhKSuJeASI90mq16NSpE7KyspCamgoHBwfRkchIcUxABjV58mRcv34dKpWKRYBIz6ysrKBSqXDt2jVMmTJFdBwyAywD9NL27t2LJUuWYMGCBXjttddExyGyCM2aNcM333yD0NBQJCUliY5DJo5jAnopBQUF8PT0RMOGDbFnzx7I5eyXRIai0+nQpUsXXLlyBWlpaXB0dBQdiYwMxwRkEBMmTMDNmzehUqlYBIgMTC6XQ6VSISsrCxMnThQdh0wY372pwnbt2oXIyEgsWrQITZs2FR2HyCK98sorWLhwISIiIrB7927RcchEcUxAFZKXlwdPT0+88sor2LlzJ/cKEAmk0+nQvXt3XLx4Eenp6XBychIdiYwExwSkV+PHj8edO3cQHx/PIkAkmFwuR3x8PG7duoXx48eLjkMmiO/i9MISExMRExODxYsXo3HjxqLjEBGAJk2aYPHixYiOjkZiYqLoOGRiOCagF5KbmwsPDw+0aNECiYmJkMlkoiMR0R90Oh169eqFs2fPIj09Hc7OzqIjkWAcE5BejBs3Drm5uYiLi2MRIDIycrkcSqUSOTk58Pf3Fx2HTAjLAJXb1q1boVQqERgYiEaNGomOQ0RP0ahRIwQGBiIuLg7btm0THYdMBMcEVC45OTnw8PCAp6cntm7dyr0CREZMkiT06dMHGo0GGRkZcHFxER2JBOGYgCrVmDFjUFBQwPEAkQmQyWSIi4tDfn4+xowZIzoOmQCWAXqujRs3IiEhAcHBwahfv77oOERUDg0aNEBQUBDUajU2b94sOg4ZOY4J6C/duXMHHh4e8PHxwaZNm7hXgMiESJKEd999FykpKdBoNHB1dRUdiQyMYwKqFKNGjcLdu3cRExPDIkBkYmQyGWJjY1FUVIRRo0aJjkNGjGWAnumnn37CsmXLEBISgnr16omOQ0QVUK9ePYSEhOC7777D+vXrRcchI8UxAT3V7du3oVAo0KZNG6xfv557BYhMmCRJ+OCDD3D8+HFoNBq4ubmJjkQGwjEBvZQRI0bg/v37iI6OZhEgMnEymQzR0dG4f/8+Ro4cKToOGSGWAXrCmjVr8P333yMsLAx16tQRHYeIKkHdunWxZMkSrFixAmvXrhUdh4wMxwT0mOzsbCgUCnTo0AFr1qzhXgEiMyJJEj766CMcPHgQGo0GNWvWFB2J9IxjAqqQYcOGQafTITIykkWAyMzIZDJERkZCq9Vi+PDhouOQEWEZoDKrVq3Cjz/+iPDwcLi7u4uOQ0R6ULt2bYSHh5f9vRMBHBPQH7KysqBQKNC1a1esWrWKewWIzJgkSfjkk0+QlJQEjUaDWrVqiY5EesIxAZWbJEnw8/ODXC5HREQEiwCRmZPJZIiIiAAADB06FOX4TEhmjmWA8MMPP2DdunWIiIjgAUVEFqJWrVqIiIjAmjVrsHLlStFxSDCOCSzcjRs3oFAo0LNnT/zwww+i4xCRgf3zn//Ezp07odFoULt2bdFxqJJxTEDPJUkShgwZAmtra4SFhYmOQ0QChIeHw9raGkOGDOG4wIKxDFiw5cuXY/369YiKikKNGjVExyEiAWrUqIGoqCisX78eK1asEB2HBOGYwEJdu3YNCoUC7777LpYtWyY6DhEJ9vnnn2Pr1q3IyMhA3bp1RcehSsIxAT2TJEkYNGgQ7OzsEBoaKjoOERmB0NBQ2NraYvDgwRwXWCCWAQuUkJCAzZs3Izo6GtWrVxcdh4iMgJubG6Kjo7Fp0yYsXbpUdBwyMI4JLMyVK1fg4eGBDz/8EAkJCaLjEJGR+b//+z9s2LABGo0G9erVEx2HXhLHBPQESZIwcOBAODg4IDg4WHQcIjJCISEhsLe3x8CBAzkusCAsAxYkPj4e27ZtQ2xsLFxdXUXHISIj5OrqitjYWGzduhUqlUp0HDIQjgksxG+//QYPDw98/PHHiI+PFx2HiIzcl19+ibVr1yIjIwMNGjQQHYcqiGMCKiNJEgYMGABnZ2cEBgaKjkNEJiAoKAhOTk4YMGAAxwUWgGXAAsTGxmLHjh2Ii4uDi4uL6DhEZAJcXFwQFxeHxMRExMXFiY5DesYyYOYuXbqEcePGYeDAgejdu7foOERkQvr06YMBAwZg7NixyMzMFB2H9IjHDJgxnU6Hnj174tdff0V6ejp/d0T0wvLy8uDh4YFmzZphx44dvMS5ieExA4To6Gjs3r0bSqWSRYCIKqRatWpQKpXYtWsXoqOjRcchPWEZMFMXLlzA+PHjMWTIEPTo0UN0HCIyYT179sTgwYPh7++Pixcvio5DesAxgRnS6XTo1q0bMjMzkZaWBicnJ9GRiMjE5efnw9PTE02aNMGuXbsgl/OzpCngmMCChYeHIykpCfHx8SwCRFQpnJycEB8fj7179yIiIkJ0HKpkLANm5tdff8XEiRMxbNgwdO3aVXQcIjIj3bp1w9ChQzFx4kScP39edByqRBwTmBGdTofOnTvj2rVrSE1NhaOjo+hIRGRmCgoK4OXlhfr162Pv3r0cFxg5jgksUGhoKA4cOACVSsUiQER64ejoCJVKhf3792PJkiWi41AlYRkwE2fPnsXkyZMxatQodOrUSXQcIjJjnTt3xsiRIzF58mScPXtWdByqBBwTmAGtVouOHTsiOzsbqampsLe3Fx2JiMxcYWEhvL294e7ujn379sHKykp0JHoKjgksSHBwMI4cOQKVSsUiQEQG4eDgAJVKhcOHDyMkJER0HHpJLAMm7syZM5g6dSrGjBmDDh06iI5DRBakY8eOGD16NKZOnYozZ86IjkMvgWMCE1ZaWor27dvj999/R0pKCqpWrSo6EhFZmKKiIvj4+MDV1RUHDx7kuMDIcExgAQICAnDixAmo1WoWASISwt7eHiqVCseOHUNAQIDoOFRBLAMmSqPRYMaMGRg3bhzefvtt0XGIyIK1a9cO48aNw/Tp0/Hzzz+LjkMVwDGBCSotLcXbb7+NgoICnDp1CnZ2dqIjEZGFu3v3Llq1agUnJyccOnQI1tbWoiMROCYwa4sWLcLJkyeRkJDAIkBERqFq1apQq9VITk7G4sWLRcehF8QyYGLS09Px9ddfY+LEiWjTpo3oOEREZd566y1MmDABM2fORHp6uug49AI4JjAhJSUleOutt3D//n0kJyejSpUqoiMRET3m3r17aNWqFezs7HDkyBHY2NiIjmTROCYwQwsWLEBaWhrUajWLABEZpSpVqkCtViM1NRULFy4UHYfKiWXARKSkpGD27NmYPHky3nzzTdFxiIieqXXr1pg0aRJmz56N1NRU0XGoHDgmMAH3799HmzZtIEkSjh8/DltbW9GRiIj+0r1799C6dWtYWVnh6NGjfN8ShGMCMzJv3jxoNBqo1Wr+QRGRSXg4LkhPT8f8+fNFx6HnYBkwcidPnsS8efMwdepU+Pj4iI5DRFRurVq1wtSpUzFv3jycOnVKdBz6CxwTGDHuZiMiU/dwzKnT6XDixAm+jxkYxwRmYM6cOThz5gzHA0RksmxtbZGQkIDTp09jzpw5ouPQM7AMGKnjx49jwYIFmDFjBry9vUXHISKqMG9vb8yYMQPffPMNTpw4IToOPQXHBEaouLgYvr6+PGkHEZmNkpIStG3bFvfu3eNJ0wyIYwITNmvWLJw7dw4JCQksAkRkFmxsbKBWq3H27FnMmjVLdBz6E5YBI3P06FEsWrQIs2bNgoeHh+g4RESVxtPTE19//TUWLlyIY8eOiY5Dj+CYwIjwEqBEZO54CXbD4pjABM2YMQMXLlyAWq1mESAis2RtbY2EhARcuHABM2bMEB2H/sAyYCQOHTqEgIAAzJkzB2+88YboOEREevPGG29g9uzZCAgIwOHDh0XHIXBMYBSKiorQsmVLuLm54cCBA7CyshIdiYhIr0pLS9GhQwfk5OQgJSUFVatWFR3JLHFMYEKmTZuGy5cvQ61WswgQkUWwtraGWq1GZmYmpk2bJjqOxWMZEGz//v0IDg7G3Llz0bx5c9FxiIgMpkWLFpg7dy6CgoJw4MAB0XEsGscEAhUWFsLb2xvu7u7Yt28f9woQkcXRarXo2LEjsrOzkZqaCnt7e9GRzArHBCZgypQpuHbtGlQqFYsAEVkkKysrqNVqXLlyBVOmTBEdx2KxDAiSlJSE0NBQfPPNN2jWrJnoOEREwjRr1gzffPMNQkJCkJSUJDqOReKYQICCggJ4eXmhfv362Lt3L+RydjIismw6nQ5dunTB1atXkZqaCkdHR9GRzALHBEZs4sSJyMrKgkqlYhEgIgIgl8sRHx+P69evY9KkSaLjWByuRAa2e/duREREYOHChXjllVdExyEiMhqvvvoqFi5ciPDwcOzZs0d0HIvCMYEB5efnw9PTE02aNMGuXbu4V4CI6E90Oh26deuGzMxMpKWlwcnJSXQkk8YxgREaP348bt26hfj4eBYBIqKneDguyM7OxoQJE0THsRhckQwkMTER0dHRWLx4MZo0aSI6DhGR0WratCkWLVqEqKgo7NixQ3Qci8AxgQHk5ubC09MTzZo1Q2JiIvcKEBE9h06nQ8+ePXHu3DlkZGRw7akgjgmMiL+/P3JycqBUKlkEiIjKQS6XQ6lUIicnB/7+/qLjmD2uTHq2bds2xMXFITAwEI0aNRIdh4jIZDRu3BgBAQGIjY3F9u3bRccxaxwT6NHvv/8ODw8PKBQKbNu2DTKZTHQkIiKTIkkSevfujZ9//hkZGRlwcXERHcmkcExgBMaMGYP8/HzExcWxCBARVYBMJkNcXBzy8vIwduxY0XHMFsuAnmzevBlqtRpBQUFo0KCB6DhERCarYcOGCAoKgkqlwpYtW0THMUscE+hBTk4OFAoFWrZsic2bN3OvABHRS5IkCe+88w7S0tKQkZEBV1dX0ZFMAscEAo0aNQpFRUWIjY1lESAiqgQymQyxsbEoLCzE6NGjRccxOywDlWz9+vX47rvvEBISgnr16omOQ0RkNurXr4/g4GAsXboUGzZsEB3HrHBMUIlu374NhUKB1q1bY8OGDdwrQERUySRJwvvvv4/k5GRoNBpUr15ddCSjxjGBACNHjsT9+/cRHR3NIkBEpAcymQwxMTEoLi7GyJEjRccxGywDlWTt2rVYsWIFlixZgrp164qOQ0RkturWrYslS5Zg+fLlWLduneg4ZoFjgkqQnZ0NhUKB9u3bY+3atdwrQESkZ5Ik4e9//zsOHz4MjUaDGjVqiI5klDgmMKDhw4dDq9UiMjKSRYCIyABkMhmioqJQWlqK4cOHi45j8lgGXtKPP/6IVatWITw8HLVr1xYdh4jIYtSuXRthYWFYuXIlVq9eLTqOSeOY4CXcvHkTCoUCnTt3xo8//si9AkREBiZJEj7++GPs27cPGo0GtWrVEh3JqHBMoGeSJGHo0KEAgIiICBYBIiIBZDIZIiMjAQBDhw5FOT7f0lOwDFTQypUrsWbNGkRERLCJEhEJVKtWLYSHh2PNmjVYtWqV6DgmiWOCCrhx4wYUCgV69OiBlStXio5DREQAPv30U+zevRsajQbu7u6i4xgFjgn0RJIkDBkyBNbW1ggPDxcdh4iI/hAeHg65XA4/Pz+OC14Qy8ALWrFiBdavX4+oqCh+r5WIyIjUrFkTkZGRWLduHb7//nvRcUwKxwQv4Nq1a/Dw8EDfvn2xfPly0XGIiOgp/v3vf2Pbtm3QaDSoU6eO6DhCcUxQySRJwuDBg2Fra4vQ0FDRcYiI6BmWLFkCW1tbDB48mOOCcmIZKKfvvvsOmzZtQnR0NNzc3ETHISKiZ3Bzc0N0dDQ2btyIZcuWiY5jEjgmKIerV69CoVDggw8+wNKlS0XHISKicvjvf/+LTZs2ISMjA/Xq1RMdRwiOCSqJJEkYOHAg7O3tERISIjoOERGVU0hICKpWrYpBgwZxXPAcLAPPoVKpsHXrVsTGxsLV1VV0HCIiKqfq1asjJiYGW7ZsgVqtFh3HqHFM8BcuX74MDw8PfPTRR1CpVKLjEBFRBfTr1w/r1q2DRqNB/fr1RccxKI4JXpIkSRgwYACcnJwQFBQkOg4REVVQcHAwHB0dMWDAAI4LnoFl4Bni4uKQmJiIuLg4uLi4iI5DREQV5OLigri4OGzfvh1KpVJ0HKPEMvAUmZmZGDt2LAYMGIA+ffqIjkNERC+pb9++6N+/P8aOHYvMzEzRcYwOjxn4E0mS0LNnT5w9exYZGRlm/3qJiCxFbm4uPDw80KJFCyQmJlrEped5zEAFRUdHY9euXVAqlSwCRERmxNnZGUqlEjt37kRMTIzoOEaFZeARFy9ehL+/PwYPHoyePXuKjkNERJWsV69eGDRoEMaNG4eLFy+KjmM0OCb4g06nQ/fu3XHx4kWkp6fDyclJdCQiItKD/Px8eHp6omnTpti5cyfkcvP9XMwxwQuKiIjA3r17ER8fzyJARGTGnJycoFQqsWfPHkRGRoqOYxRYBgCcP38eEydOxNChQ9GtWzfRcYiISM+6d+8OPz8/TJgwARcuXBAdRziLHxPodDp06dIFV65cQVpaGhwdHUVHIiIiAygoKICnpycaNmyIPXv2mOW4gGOCclqyZAn2798PlUrFIkBEZEEcHR2hUqmwb98+hIWFiY4jlEWXgbNnz2Ly5MkYOXIkOnfuLDoOEREZWJcuXTBixAhMmjQJ586dEx1HGIsdE2i1WnTq1AlZWVlITU2Fg4OD6EhERCRAYWEhvL29Ubt2bSQlJcHKykp0pEpT3vXb2oCZ9EJbUoLstDRkJSfj5smTKLh+Hdp792BVpQoc69RBrVat4O7ri5peXrCysSn7uZCQEBw+fBhJSUksAkREFszBwQEqlQqdO3dGaGgoxowZ89j9FV1nTInJ7hnIzcxEWnQ0UqOiUJyTAwCQ29hAV1JS9phH/23n6grvIUPgNXgwrt+9Cx8fH/j5+SEwMFBIfiIiMi5jxoxBVFQUUlJS0Lx585daZ5wbNRLyGv6svOu3yZWBe7m52Ovvj3SlEjK5HJJWW+6flVlZQdLpcKFGDeyrVg3H0tJgb2+vx7RERGQqioqK0LJlS7g7O2Oqtzcy4uMrvM549u+PLgEBqCJ4zTTLbxNcSkxEfIsWyFCpAEl6oV8QgAePlyQ0zs7GwN9/x80DB/SUlIiITI29vT2C/PzQ9cQJpMfHv9Q6k6FSIb5FC1xKTNRT2splMmXgZFgYVvfujaKbN1/4l/NncgClOTlY3bs3ToWHV05AIiIyaSfDwnB67Fg4yWSQPX+n+V+StFoUZWWZzDpjEmXgVHg4do8YAQCQdLpKec6Hz7Nr+HCT+EUREZH+PLrOvGwReMiU1hmjLwOXEhOxa/hwvW5j1/DhJrMrh4iIKhfXGSMvA/dyc7H1iy8g0/MpImVyObb264d7eXl63Q4RERkXrjMPGHUZ2Ovvj6Ls7EobDTyLpNOh6OZN7B03Tq/bISIi48J15gGjLQO5ly4hXal84mDB3kolRhcXo4aHxxM/02biRPhLEpq+917Zbc3/+U/836lTGH33LoZcvYquQUGwecpJhiStFulKJXIzMyv/xRARkVF69cMPn1hnBl68CH9JeuK/Hn+63HFNb298tGkTBmVmYlRREYbdvo1/HzqE1z///KnbkslksK1WDdr79/X2eirKaM9AmBYT89Tvd+4ZPRqNundH34QELH/rLehKSwEANTw80G7WLGSoVLiwaRMA4PV//xvvLl+OtNhY7BkzBq7NmqHTwoVwe+MNrO7d+4ltyuRypMXEoOO8efp/gUREJFRpcTEgkz31visHDiDJ3/+x24qysh77t52LC/IuX8bp779HwdWrsHFwwOuff453ly2Dc+PGOPLIWiKTy/HhunWo16EDLu/di8a9elX+C3oJRnnSIW1JCSLd3cvO+PRnDbt3xyeJiTg8Zw4Off015NbW+M/x47CrXh1qT0/cz8uDTC7H4MuXkZ2ejjV9+pT9bIvPPsN7K1ZgTd++uLht2xPPbefqCr+sLJM9pSQRET2fTqtFwdWryE5Lw7r333/svoEXL+JWRsYTt5fXvw8fhmPduoh55CyErUaNQpeAAHzfvj1yzp412Dpj0icdyk5Le2YRAIDfdu1CalQU3poyBe6tWqHd11+jVsuW2N6/P+7/cXBGnbZt4Vi37oMTFD3i7I8/4n5+Pl79+9+f+tzFOTm4lZ5eeS+GiIiMzs2UFL0dJ3D31q2yvdYP+Y4ahSv79uH60aNGuc4YZRnISk5+7mOSxo9H/m+/4YPVq9Fm4kSkREYic+fOsvsfHlNwKy3tsZ/TlZbizpkzTz3m4EW2T0REput57/P1O3XCyLw8jLl/H19qNHhz7Nhnf+NAJoPMygpVa9RASz8/NO7dG8cWLiy726l+fTg3aYJb6enoMG8e/G7cQK2WLSvx1bw8oywDN0+ehPw5u09KiopwYNo0ODdpgqLsbCSNH//Y/VXd3AAAd+/ceeJn7965U3b/n8ltbFgGiIjM3M2TJ59534XNm7Fn1CisffddbPj4Y2SdPIkuAQHoo1Y/9fE9IiIwrrQUw7Kz0SUoCLtHjkRaTEzZ/Y716gEAFF98gVc//BC7R4/GySVLKvX1vCyjPICw4Pr1x64K9VQyGXxGjIBOq4V9rVqo6e2Na4cOPfm4ZxwS8axDJXQlJSi8ceNFIxMRkQkpuH79mff9+QRE5zdsQHFODlqNGIHkwEDcTEl57P6j8+cjPS4O9rVq4ZX330f3sDDYODjgREAAAJTtUbCys8Pad95B3m+/QXv3LnxHjarcF/USjHLPgPbevec+prW/P+q1a4fN//43cs6dQ5/4eFjb2ZXdf/f2bQB46h6AqtWro/gpewweKi0urkBqIiIyFXJra8jkcsitrVHF2RlWtrZ/+fifly0D8OB4tD/Lv3wZWcnJuLh1K3YOHfrgW2nffIOqNWoA+N96dOfMGeT99hsA41tnjLIMWFWp8pf3u73+OtrPng1NQgJ+WbUK2/r1g8urr6LDI1/jeHhwRg1Pz8d+VmZlheotWuBWRsYzn//RUkFERObnwzVrUK1hQzTp0wcjfv8d3n5+f/l42R9fQSzPQYc3jh2DlY0NnJs2BQD8fv48SgoLH3uMsa0zRlkGHOvUeeYxAzIrK/RNSMDdW7ew+49dLNePHkVyYCBajRqFuu3ald1WcO0aPPr1e+znm338MWydnHBu7dqnPr/cxgYOtWtX3oshIiKjcyIwEIU3buDa4cNY2aULzq5e/ZePV/zf/wEArh858tznbtC1K3RaLXIvXADw4KR2v65fD7fXX0e1Ro2Mcp0xymMGarVqBV109FPve2vyZNRu3Rqr+/TBvdzcstsPTJ+Opu+/jz7x8VjasiVKi4uRNGEC3l22DD2jonDm++/h8tpr6LxoES4lJuLS9u1PfX5dSQncfX318rqIiMg42Dg6orS4GHdv38blpKSy21t89hmaffQRLmzejNzMTNi5uKDZJ5/g9c8+Q4ZKhexHvqHWMzoa9/PycOPYMRRmZaFqjRpo/sknaPGvf+HYokW4e+tW2WMPTJ+OJn374h/btuHQ11/j1b/9zZAv97mMsgw8azGu6eWFt6dPR2pMzBOLufbePWzr1w+fHTyIDvPmYe+4cTi9fDkkrRZtJk2Col8/FN+5A83SpTgwdWqFtk9ERObhWe/zuRcuoIqLCzrMn4+qbm7QlZTglkaDHX5+SP3Th9Trhw9D8eWXUHzxBaq4uKCkoADZqanY/J//4PTy5U887w8dO6LjggXoFRMDW0dHvb22ijDJMxDqE89ASERk/ixlnTHpMxBa2djAe8gQyKysDLpdmZUVvP38WASIiMwc15nHGWUZAACvwYP1fknJP5N0OngNGmTQbRIRkRhcZ/7HaMuAc6NG8Ozf32CtTWZlBc/+/eH8yIUliIjIfHGd+R+jLQMA0CUgAPa1aj37fNCVRCaXw75WLXT542xRRERkGbjOPGDUZaBKtWroq1brfTeOpNOhr1qNKgY4OJKIiIwH15kHjLoMAEDjXr3QPSxMr9voHh6Oxr166XUbRERknLjOmEAZAACfYcPKflGVtSvn4fN0Dw+Hz9ChlfKcRERkmix9nTGJMgA8+EV9vH077N3dX/pgD5mVFezd3fHx9u1G/wsiIiLDsOR1xmTKAPBgV85Xp0/D48svAZnshX9ZMisrQCaDx5df4qszZ4x6lw0RERmepa4zRnkGwvLIzcxEWkwMUiMjy84gJbexga6kpOwxj/7bztUV3n5+8Bo0yCi/1kFERMbFHNaZ8q7fJlsGHtKWlOBWejqykpORlZyMwhs3UFpcDGs7OzjUrg13X1+4+/qihqen0Z3xiYiIjJ8przMWUwaIiIjo6Uz62gRERERkOCwDREREFo5lgIiIyMKxDBAREVk4lgEiIiILxzJARERk4VgGiIiILBzLABERkYVjGSAiIrJwLANEREQWjmWAiIjIwrEMEBERWTiWASIiIgtnXZ4HPbywYV5enl7DEBERUeV5uG4/7wLF5SoD+fn5AIAGDRq8ZCwiIiIytPz8fDg7Oz/zfpn0vLoAQKfT4dq1a3BycoJMJqvUgERERKQfkiQhPz8fdevWhVz+7CMDylUGiIiIyHzxAEIiIiILxzJARERk4VgGiIiILBzLABERkYVjGSAiIrJwLANEREQWjmWAiIjIwv0/Hd3/Wh5QlgoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import networkx as nx\n",
    "from deap.gp import graph\n",
    "from networkx.drawing.nx_agraph import graphviz_layout\n",
    "\n",
    "function_name = {\n",
    "    'add':'Add',\n",
    "    'sub':'Sub',\n",
    "    'mul':'Mul',\n",
    "    'neg':'Neg'\n",
    "}\n",
    "\n",
    "def is_number(string):\n",
    "    try:\n",
    "        float(string)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "\n",
    "\n",
    "def plot_a_tree(tree=hof[0]):\n",
    "    red_nodes = []\n",
    "    purple_nodes = []\n",
    "    blue_nodes = []\n",
    "    for gid, g in enumerate(tree):\n",
    "        if (\n",
    "                hasattr(g, \"value\")\n",
    "                and isinstance(g.value, str)\n",
    "                and g.value.startswith(\"ARG\")\n",
    "        ):\n",
    "            g.value = g.value.replace(\"ARG\", \"X\")\n",
    "\n",
    "        if g.name in function_name:\n",
    "            g.name = function_name[g.name]\n",
    "\n",
    "        if hasattr(g, \"value\") and (\n",
    "                is_number(g.value)\n",
    "                or (g.value.startswith(\"X\") and int(g.value[1:]) < X.shape[1])\n",
    "        ):\n",
    "            # 基础节点\n",
    "            red_nodes.append(gid)\n",
    "        elif hasattr(g, \"value\") and g.value.startswith(\"X\"):\n",
    "            g.value = \"$\\phi$\" + str(int(g.value.replace(\"X\", \"\")) - X.shape[1] + 1)\n",
    "            purple_nodes.append(gid)\n",
    "        elif hasattr(g, \"value\") and g.value.startswith(\"$\\phi$\"):\n",
    "            purple_nodes.append(gid)\n",
    "        else:\n",
    "            # 深蓝色节点\n",
    "            blue_nodes.append(gid)\n",
    "    nodes, edges, labels = graph(tree)\n",
    "    g = nx.Graph()\n",
    "    g.add_nodes_from(nodes)\n",
    "    g.add_edges_from(edges)\n",
    "    pos = graphviz_layout(g, prog=\"dot\")\n",
    "    red_nodes_idx = [nodes.index(n) for n in nodes if n in red_nodes]\n",
    "    purple_nodes_idx = [nodes.index(n) for n in nodes if n in purple_nodes]\n",
    "    blue_nodes_idx = [nodes.index(n) for n in nodes if n in blue_nodes]\n",
    "    nx.draw_networkx_nodes(\n",
    "        g, pos, nodelist=red_nodes_idx, node_color=\"darkred\", node_size=500\n",
    "    )\n",
    "    nx.draw_networkx_nodes(\n",
    "        g, pos, nodelist=purple_nodes_idx, node_color=\"indigo\", node_size=500\n",
    "    )\n",
    "    nx.draw_networkx_nodes(\n",
    "        g, pos, nodelist=blue_nodes_idx, node_color=\"darkblue\", node_size=500\n",
    "    )\n",
    "    nx.draw_networkx_edges(g, pos)\n",
    "    nx.draw_networkx_labels(g, pos, labels, font_color=\"white\")\n",
    "\n",
    "for tree in hof[0]:\n",
    "    plot_a_tree(tree)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b39a6243da71a6f",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
